[Powered by Google Translate] ROB BOWDEN: ვისაუბროთ იმაზე compilers.
სანამ ამ ეტაპზე, თქვენ უბრალოდ აკრეფილი თქვენი კოდის შევიდა
რამდენიმე ფაილი გამოგზავნილი მეშვეობით ამ დიდი შავი ყუთი რომ არის
Clang, და გარეთ მოდის თქვენი შესრულებადი ფაილი, რომელიც არ
ზუსტად რა თქვენ წერდა თქვენი კოდის.
როგორც ჯადოსნური როგორც რომ ყოფილიყო, ჩვენ ვაპირებთ უფრო ახლოს
შეხედეთ, რა ხდება რეალურად
როდესაც ჩვენ კომპილაციის ფაილი.
ასე რომ რას ნიშნავს შედგენა რაღაც?
>> ისე, ყველაზე ზოგადი გაგებით, უბრალოდ ნიშნავს
ტრანსფორმირებას კოდი დაწერილი ერთი
პროგრამირების ენა სხვა.
მაგრამ, როგორც წესი, როდესაც ადამიანები ამბობენ, რომ შეადგინონ რაღაც, მათ
გულისხმობს ისინი იღებენ მას მაღალ დონეზე პროგრამირების
ენის ქვედა დონის პროგრამირების ენაზე.
ეს შეიძლება მოგვეჩვენოს, როგორიცაა ძალიან სუბიექტური თვალსაზრისით.
მაგალითად, თქვენ ალბათ არ ფიქრობენ C როგორც მაღალი
დონის პროგრამირების ენა, მაგრამ თუ თქვენ ჩვენგან კომპილირება.
მაგრამ ყველა ნათესავი.
როგორც ვნახავთ, ასამბლეის კოდი და საბოლოოდ მანქანა
კოდი რომ ჩვენ კომპილაციის ქვემოთ არის მკვეთრად ქვედა დონის
ვიდრე C.
მიუხედავად იმისა, რომ ჩვენ უნდა გამოყენებით Clang დღევანდელ დემონსტრირება,
ბევრი იდეები აქ აწარმოოს მეტი სხვა compilers.
>> იყიდება Clang, არის ოთხი ძირითადი ნაბიჯები საერთო
კომპილაცია.
ეს არის ერთი, preprocessing კეთდება preprocessor, ორი,
compilation კეთდება შემდგენელი, სამი, იკრიბებიან
კეთდება assembler და ოთხი,
აკავშირებს კეთდება linker.
იგი შეიძლება დამაბნეველი რომ ერთი substeps საერთო
Clang compilers ეწოდება შემდგენელი, მაგრამ
ჩვენ კიდევ, რომ.
ჩვენ უნდა გამოყენებით მარტივი Hello world პროგრამა როგორც ჩვენი მაგალითი
მთელ ამ ვიდეო.
ავიღოთ სახეს.
>> პირველი ნაბიჯი არის preprocessing.
რას preprocessor გავაკეთო?
In საკმაოდ ბევრი ყველა C პროგრამის თქვენ ოდესმე წაიკითხა ან წერილობითი,
თქვენ გამოყენებული ხაზების კოდი, რომელიც იწყება hash.
მე ეძახით hash, თუმცა შესაძლოა ასევე ეძახით ფუნტი, ნომერი
მოაწეროს, ან მკვეთრი.
ნებისმიერი ასეთი ხაზი preprocessor დირექტივა.
თქვენ ალბათ გინახავთ # განსაზღვრა და # მოიცავს ადრე, მაგრამ იქ
არის კიდევ რამდენიმე რომ preprocessor აღიარებს.
მოდით დაამატოთ # განსაზღვრავს ჩვენი ცხოვრება მშვენიერია მაგალითია.
ახლა მოდით აწარმოებს მხოლოდ preprocessor ამ ფაილის.
გავლით clage-E დროშა, თქვენ ავალებს მას აწარმოებს
უბრალოდ preprocessor.
ვნახოთ, რა მოხდება.
როგორც ჩანს Clang მხოლოდ SpitS ყველაფერი
ბრძანებათა ზოლს.
იმისათვის, რომ გადარჩენა ყველა ამ გასასვლელი ახალი ფაილის მოუწოდა
hello2.c, ჩვენ დამატება> hello2.c ჩვენი ბრძანება.
ახლა მოდით შევხედოთ ჩვენი preprocessed ფაილი.
>> Whoa, თუ რა მოხდა ჩვენი მოკლე პატარა პროგრამა?
თუ ჩვენ წავიდეთ ყველა გზა ბოლოში ამ ფაილის, ვნახავთ,
ზოგიერთი კოდი, რომ ჩვენ რეალურად დაწერა.
გაითვალისწინეთ, რომ # განსაზღვროს არის წასული და ყველა ინსტანციის სახელი
შეიცვალა ზუსტად ის, რაც ჩვენ მითითებული
# განსაზღვრავს ხაზის.
რა არის ყველა ამ typedefs და ფუნქციის დეკლარაციების
ზედა ფაილი?
გაითვალისწინეთ, რომ # განსაზღვროს არ იყო მხოლოდ preprocessor
დირექტივა, რომ ჩვენ მითითებული.
ჩვენ ასევე # მოიცავს stdio.h.
ასე რომ ყველა გიჟები ხაზები რეალურად მხოლოდ stdio.h გადაწერილი
და pasted შევიდა ზევით ამ ფაილის.
ამიტომ header ფაილი იმდენად სასარგებლოა ფუნქცია
დეკლარაციებს.
იმის ნაცვლად, რომ სჭირდება კოპირება და ჩასვით ყველა ფუნქცია
დეკლარაციების თქვენ აპირებთ გამოყენებით ზედა თქვენი ფაილი,
preprocessor იქნება დააკოპირეთ და ჩასვით მათ header
ფაილი თქვენ.
>> ახლა, როდესაც ჩვენ გავაკეთეთ preprocessing, ჩვენ გადაადგილება გადატანა
კომპილაცია.
მიზეზი ჩვენ მოვუწოდებთ ამ ნაბიჯით compilation არის რადგან ეს
ნაბიჯი სადაც Clang რეალურად აკეთებს შედგენის საწყისი C-დან
ასამბლეის კოდი.
იმისათვის, რომ Clang კომპილაციის ფაილი ქვემოთ ასამბლეის, მაგრამ
გააგრძელოს არ შემდგომი, მსგავ-S დროშა
ბრძანებათა ზოლს.
მოდით შევხედოთ ასამბლეის
ფაილი, რომელიც იყო outputted.
როგორც ჩანს საკმაოდ სხვადასხვა ენაზე.
ასამბლეის კოდექსი ძალიან პროცესორი კონკრეტული.
ამ შემთხვევაში, რადგან CS50 ელექტრო გაშვებულია
ვირტუალური x86 პროცესორი, ეს არის x86 ასამბლეის კოდი.
ძალიან ცოტა ადამიანს წერენ უშუალოდ ასამბლეის კოდი ამ დღეებში,
მაგრამ ყველა C პროგრამის ოდესმე წერენ იღებს გარდაიქმნება ქვემოთ
შევიდა ასამბლეის.
ერთხელ, ჩვენ მოვუწოდებთ ამ ნაბიჯით შედგენის C შევიდა ასამბლეის
რადგან ჩვენ ვაპირებთ საწყისი უმაღლეს დონეზე, რათა ქვედა დონის
პროგრამირების ენა.
>> რით ასამბლეის ქვედა დონეზე, ვიდრე C?
ისე, წელს ასამბლეის, ჩვენ ძალიან შეზღუდული, თუ რა შეგვიძლია გავაკეთოთ.
არ არსებობს, თუ მისი, ხოლო ის, ამისთვის არის, ან მარყუჟების ნებისმიერი სახის.
მაგრამ თქვენ შეგიძლიათ განახორციელოთ იგივე რამ, რომ ეს კონტროლი
სტრუქტურების გთავაზობთ გამოყენებით შეზღუდული მოქმედებები
ასამბლეის არ უზრუნველყოფს.
მაგრამ ვხედავთ, თუ რამდენად დაბალი დონე ასამბლეის ნამდვილად არის, მოდით წავიდეთ
ერთი ნაბიჯი შემდგომი ჩვენს კომპილაცია, იკრიბებიან.
ეს assembler ის სამუშაო გარდაქმნის ასამბლეის კოდი
შევიდა ობიექტის ან მანქანა კოდი.
გახსოვდეთ, რომ assembler არ გამომავალი სამონტაჟო;
პირიქით, სჭირდება წელს შეკრებისა და მასალები მანქანა კოდი.
მანქანა კოდი არის ფაქტობრივი 1 და 0 ს რომ CPU can
მესმის, თუმცა ჩვენ ჯერ კიდევ აქვს პატარა bit მუშაობის დაუტოვებიათ
სანამ ჩვენ შეგვიძლია მას მოვთხოვოთ ჩვენი პროგრამა.
მოდით შეიკრიბება ჩვენი ასამბლეის კოდი გავლით
Clang-C დროშა.
ახლა ვნახოთ რა აწყობილი ფაილი.
>> ისე, რომ არ დაგვეხმარება ძალიან.
გახსოვდეთ, რომ მანქანა კოდი არის პირობა და zeros, რომ
თქვენს კომპიუტერში მესმის.
ეს არ ნიშნავს, ადვილი ჩვენთვის გასაგებია.
ასე ზუსტად როგორ დაბალი დონე ასამბლეის?
თითქმის იდენტურია ობიექტის კოდი.
Going საწყისი ასამბლეის ობიექტის კოდი ბევრად უფრო
მთარგმნელობითი ვიდრე ტრანსფორმაციის, რის გამოც
შეიძლება არ განიხილავს assembler to
რაიმე ფაქტობრივი შედგენა.
ფაქტობრივად, ეს საკმაოდ ადვილი ხელით თარგმნოთ
ასამბლეის მანქანა კოდი.
ეძებს ასამბლეის მთავარი ფუნქცია, რომ პირველ ხაზზე
მოსდის შეესაბამება თექვსმეტობითი 0x55.
In ორობითი, რომ 1010101.
მეორე ხაზი ხდება შეესაბამება თექვსმეტობითი 0x895.
და შემდეგი, 0x56.
იმის გათვალისწინებით, შედარებით მარტივი მაგიდა, შეგიძლიათ თარგმნოს
ასამბლეის შევიდა კოდი, რომელიც მანქანები მესმის ძალიან.
>> ასე რომ ერთი დარჩენილი ნაბიჯი
კომპილაცია, რომელიც აკავშირებს.
Linking აერთიანებს bunch of ობიექტი ფაილი ერთ დიდი ფაილი
რომ თქვენ შეგიძლიათ რეალურად შეასრულოს.
Linking ძალიან სისტემის დამოკიდებული.
ასე რომ უმარტივეს გზას მიიღოთ Clang უბრალოდ დაუკავშირონ ობიექტი
ფაილი ერთად არის მოვუწოდო Clang ყველა ფაილი, რომელიც
გსურთ დაუკავშირონ ერთად.
თუ თქვენს მიერ მითითებული. O ფაილები, მაშინ იგი არ უნდა reprocess,
კომპილირდება, და შეიკრიბება ყველა თქვენი კოდის.
მოდით ჩააგდოს მათემატიკის ფუნქცია ჩვენს ფაილი, ასე რომ ჩვენ გვაქვს
რაღაც უკავშირებენ სისტემაში
ახლა მოდით კომპილირება უკან ქვემოთ ობიექტის კოდი და
მოვუწოდებთ Clang მასზე.
Oops.
ვინაიდან ჩვენ მოიცავდა მათემატიკის ფუნქცია, ჩვენ უნდა ბმულზე
მათემატიკის ბიბლიოთეკა-LM.
>> თუ გვინდოდა უკავშირებენ ერთად bunch of. O ფაილი, რომელიც ჩვენ
წერდა ჩვენი საკუთარი, ჩვენ უბრალოდ მიუთითოთ მათ ყველა დროს
ბრძანებათა სტრიქონიდან.
შეზღუდვა არის, რომ მხოლოდ ერთი ამ ფაილებს უნდა
რეალურად დააკონკრეტა მთავარი ფუნქცია, ანდა
შედეგად შესრულებადი არ ვიცი სად უნდა დაიწყოს
გაშვებული თქვენს კოდი.
რა სხვაობაა სასურველი ფაილი ბმულზე
ერთად-მ და მხოლოდ სასურველი ფაილი პირდაპირ?
არაფერი.
უბრალოდ, Clang ხდება იცით ზუსტად რა ფაილი
რაღაც-LM ხდება მიმართოს.
თუ იცოდნენ, რომ ფაილი თავს, შეგიძლიათ მიუთითოთ იგი
მკაფიოდ.
უბრალოდ გვახსოვდეს, რომ ყველა-L დროშები უნდა მოვიდეს ბოლოში
თქვენი კლიენტის მოთხოვნა.
>> და ეს ყველაფერი არის იგი.
როდესაც თქვენ მხოლოდ აწარმოებს Clang ზოგიერთ ფაილებს, ეს არის ის, რაც ეს
რეალურად აკეთებს.
ჩემი სახელი არის რობ Bowden, და ეს არის CS50.