1 / 44

Lecture 11

Lecture 11. System Software & Assembly Language (S&G, §§6.1–6.3). Important Reminder!. We hope you now have a clear understanding of what CS 100 is about and what is expected of you

casiano
Download Presentation

Lecture 11

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 11 System Software& Assembly Language (S&G, §§6.1–6.3) CS 100 - Lecture 11

  2. Important Reminder! • We hope you now have a clear understanding of what CS 100 is about and what is expected of you • We hope that you have discovered that, by applying yourself, you can learn many interesting ideas from computer science • However, if this is not the course for you, we remind you that you can still withdraw (until February 23) CS 100 - Lecture 11

  3. Read S&G §6.4(Operating Systems)for Thursday CS 100 - Lecture 11

  4. Putting Clotheson the Naked Machine • Imagine if we had to use the “naked” Von Neumann machine discussed last week • Must program purely in binary (1’s and 0’s) • Must not make mistakes • Must manually load instructions into memory • Must manually load address of first instruction into PC • Bottom line: Von Neumann machine designed from perspective of machine, not humans! CS 100 - Lecture 11 (slide < C. Hundhausen)

  5. Putting Clotheson the Naked Machine (2) • The Von Neumann Machine needs a user interface • Hide messy details of hardware from user • Communicate with user using the user’s language, not binary • Provide easy access to computer’s resources • Prevent user from damaging hardware • System software provides just such an interface; think of it as a well-designed dashboard CS 100 - Lecture 11 (slide adapted < C. Hundhausen)

  6. Putting Clotheson the Naked Machine (3) Example: Carry out the computation:if (a > b) thenset c to a + b elseset c to a – bwrite value of c to disk CS 100 - Lecture 11 (slide adapted < C. Hundhausen)

  7. Putting Clotheson the Naked Machine (4) • Imagine if you were responsible for • Fetching the values a, b from memory • Loading them into ALU registers • Putting the result into memory location c • Writing c to proper sector on a disk • Should a programmer really have to worry about such things as registers and the ALU? No! • System software provides a virtual machine that’s much friendlier than the Von Neumann machine CS 100 - Lecture 11 (slide adapt. < C. Hundhausen)

  8. System Software Types of system software: • Language translators • Assemblers • Translate assembly language into machine language • Compilers • Translate high-level programming languages into assembly language or machine language CS 100 - Lecture 11 (slide adapt. < C. Hundhausen)

  9. System Software (2) Types of system software (cont.) • Memory managers • Allocate and manage memory space for programs and data; load data and programs into memory • File systems • Allow us to read from and write to to mass storage devices like hard disks and CD-ROMs • Scheduler • Schedules programs to be executed; maintains priority queue so that higher priority programs are executed first • Utilities • Text editors • Graphics libraries • Graphical user interface libraries • Debuggers CS 100 - Lecture 11 (slide < C. Hundhausen)

  10. System Software (3) • We do not have time to cover all types of system software in a single week • In order to get a taste of virtual machines and systems software, we will focus on two specific types of system software • Assemblers (this lecture) • Operating systems (next lecture) CS 100 - Lecture 11 (slide < C. Hundhausen)

  11. Assemblers andAssembly Language CS 100 - Lecture 11

  12. Assembly Language • As we have learned, it is difficult to write programs in machine language • We don’t deal well with 1’s and 0’s • We don’t deal well with numeric variable names • Machine language is difficult to change • Assembly language is a first step toward a more user-friendly programming language • Supports English command set (e.g., LOAD, STORE) • Each command translates directly into a single machine language command • Supports mnemonic variable naming (e.g., “COUNT”) • Supports “pseudo-ops” for data generation • Supports comments CS 100 - Lecture 11 (slide adapt. < C. Hundhausen)

  13. Assembly Language (cont.) Locating assembly language on the programming language continuum: CS 100 - Lecture 11 (slide < C. Hundhausen)

  14. Set sum to 0 Set count to 1 While count ≤ 10 do Set sum to sum + count Increment count Output sum 1 clear sum 2 load one 3 store count 4 load count 5 compare eleven 6 jumpeq line 12 8 add sum 9 store sum 10 increment count 11 jump line 4 12 out sum 13 halt Example: Output Sum of 1, …, 10 CS 100 - Lecture 11 (slide < S. Levy)

  15. 1 clear sum 2 load one 3 store count 4 load count 5 compare eleven 6 jumpeq line 12 8 add sum 9 store sum 10 increment count 11 jump line 4 12 out sum 13 halt 000000000000 1101 000000001111 000000000001 0000 000000001101 000000000010 0001 000000010000 000000000011 0000 000000010000 000000000100 0111 000000011110 000000000101 1010 000000001010 000000000110 0011 000000001111 000000000111 0001 000000001111 000000001000 0100 000000010000 000000001001 1000 000000000011 000000001010 1110 000000001111 000000001011 1111 000000000000 000000001100 0000 000000000000 (zero) 000000001101 0000 000000000001 (one) 000000001110 0000 000000001011 (eleven) 000000001111 0000 000000000000 (sum) 000000010000 0000 000000000000 (count) Example: Output Sum of 1, …, 10 CS 100 - Lecture 11 (slide < S. Levy)

  16. Problems With Machine Language • Binary op codes are difficult to remember • Uses binary addresses for data, but humans are used to symbols (PI, LENGTH, etc.) • Hard to tell the difference between data and instructions CS 100 - Lecture 11 (slide < S. Levy)

  17. Labeling Principle • Labeling Principle: • Avoid arbitrary sequences more than a few items long • Do not require the user to know the absolute position of an item in a list • Instead, associate a meaningful label with each item and allow the items to occur in any order • Example: symbolic labels for instructions & data CS 100 - Lecture 11

  18. Tedious and Error-Prone • Editing code is unbelievably difficult • Must shift instructions and data in memory • Must recalculate and edit addresses of operands • Some errors can go unnoticed • The operand of a jump can be the address of a datum • The operand of a data manipulation can be the address of an instruction • The HALT instruction might not exist CS 100 - Lecture 11 (slide < S. Levy)

  19. Automation Principle • Automation Principle: Automate mechanical, tedious, or error-prone activities. • Examples: • Translation of decimal numbers and character data to binary • Translation of symbolic operation names to binary op codes CS 100 - Lecture 11

  20. Assembly Language • Provides built-in symbols for op codes (LOAD, STORE, etc.) • Address fields must also be programmer-named symbols (PI, ENDIF, etc.) • Special syntax picks out data from instructions CS 100 - Lecture 11 (slide < S. Levy)

  21. Opcode Symbols Binary OpcodeAssembly Language Symbol 0000 LOAD 0001 STORE 0010 CLEAR 0011 ADD 0100 INCREMENT 0101 SUBTRACT 0110 DECREMENT 0111 COMPARE 1000 JUMP 1001 JUMPGT 1010 JUMPEQ 1011 JUMPLT 1100 JUMPNEQ 1101 IN 1110 OUT 1111 HALT CS 100 - Lecture 11 (slide < S. Levy)

  22. Operand Symbols • Can be any symbol except those in the op code set • Two types: • Labels of data (serve as variables and constants) • Labels of instructions (destinations of jumps) CS 100 - Lecture 11 (slide < S. Levy)

  23. <any but jump opcode> <a label> … <a label>: .data <a decimal integer> load n … n: .data 50 Data Labels Data labels name variables and are declared with the .data directive Format of data label: Example: CS 100 - Lecture 11 (slide < S. Levy)

  24. <jump opcode> <a label> … <a label>: <another instruction> jumpgt okay … okay: out answer Instruction Labels Instruction labels name instructions which are the destinations of jumps Format of instruction label: Example: CS 100 - Lecture 11 (slide < S. Levy)

  25. .begin halt .end 000000000000 1111 000000000000 Example: The Simplest Assembly Language Program This program executes one instruction and halts. .begin and .end are not instructions. They are directives that tell the computer where the program begins and ends. CS 100 - Lecture 11 (slide < S. Levy)

  26. .begin out eleven halt zero: .data 0 one: .data 1 eleven: .data 11 .end 000000000000 1110 000000000100 000000000001 1111 000000000000 000000000010 0000 000000000000 000000000011 0000 000000000001 000000000100 0000 000000001011 Instructions Data Format: <symbol>: .data <decimal integer> Example: Declaring Data Labels This program reserves three cells of memory for data. The computer initializes these cells with the given numbers before any instructions are executed. CS 100 - Lecture 11 (slide < S. Levy)

  27. .begin in first in second load first add second store sum out sum halt first: .data 0 second: .data 0 sum: .data 0 .end 000000000000 1101 000000000111 000000000001 1101 000000001000 000000000010 0000 000000000111 000000000011 0011 000000001000 000000000100 0001 000000001001 000000000101 1110 000000001001 000000000110 1111 000000000000 000000000111 0000 000000000000 000000001000 0000 000000000000 000000001001 0000 000000000000 Example: Output the Sum of Two Input Numbers CS 100 - Lecture 11 (slide < S. Levy)

  28. // Absolute value Input X If X < 0 Set X to –X Output X -- Absolute value .begin in x load zero compare x jumpgt endif subtract x store x endif: output x halt x: .data 0 zero: .data 0 .end Full Example: Output Absolute Value High-level pseudocode Assembly language Comment Use of label Declaration of label CS 100 - Lecture 11 (slide < S. Levy)

  29. Set sum to 0 Set count to 1 While count ≤ 10 do Set sum to sum + count Increment count Output sum .begin clear sum load one store count while: load count compare eleven jumpeq endwhile add sum store sum increment count jump while endwhile: out sum halt one: .data 1 eleven: .data 11 sum: .data 0 count: .data 0 .end Full Example: Output Sum of 1 .. 10 CS 100 - Lecture 11 (slide < S. Levy)

  30. Translation to Machine Code • A program called an assembler translates an assembly language program to an equivalent program in machine code • The assembler keeps track of all the binary op codes and addresses • The assembler also catches some errors CS 100 - Lecture 11 (slide < S. Levy)

  31. Editor Not OK (error messages) Assembler OK Run-time system Check for syntax errors and translate to machine code Execute the machine language program Program Development Create assembly language program CS 100 - Lecture 11 (slide < S. Levy)

  32. Example Syntax Errors .begin in width in second load first add second store sum out sum first: .data 0 second: .data 0 sum: .data 0 halt .end width has not been declared as a data label The halt instruction occurs below the data declaration section The assembler prevents this incorrect program from running CS 100 - Lecture 11 (slide < S. Levy)

  33. Security Principle • Security Principle: No program that violates the definition of the language, or its own intended structure, should escape detection. • C. A. R. Hoare • Examples: • Detect undefined symbolic labels • Detect multiple definition of symbolic labels CS 100 - Lecture 11

  34. Benefits of Assembly Language • Maintenance is much easier – just edit and assemble • Code is much easier to understand • Some errors are caught automatically before execution CS 100 - Lecture 11 (slide < S. Levy)

  35. Problems With Assembly Language Still reflects underlying machine architecture and operations • Uses load, add, store instead of algebraic notation for arithmetic expressions (x = y + z) • No structured control statements like while and if/else • Data are typeless (no int, char, String) CS 100 - Lecture 11 (slide < S. Levy)

  36. Problems With Assembly Language (2) • Each machine has a different architecture and instruction set, so it needs a different dialect of assembly language – Tower of Babel! • Must rewrite programs for each new machine that comes along CS 100 - Lecture 11 (slide < S. Levy)

  37. Portability Principle Avoid feature or facilities that are dependent on a particular computer or a small class of computers CS 100 - Lecture 11

  38. A Better Programming Language • We would like one standard language with translators for different machines • This language should express the logic of problem solving more than the logic of a machine’s architecture • This language should be more like pseudocode CS 100 - Lecture 11 (slide < S. Levy)

  39. High-Level Languages • Code looks more like pseudocode, allows logic of problem solving to be expressed in syntax • One standard for each language (“write once, run anywhere”) • Compilers translate code to machine language of various target machines • Error handling is much more extensive CS 100 - Lecture 11 (slide < S. Levy)

  40. Examples • BASIC (1960s) • Pascal (1970s) • C++ (1980s) • Java (1990s) • ? CS 100 - Lecture 11 (slide < S. Levy)

  41. Implementing an Assembler • An Assembler is a program. What is it written in? • You can write it in machine language for your computer, but that’s very difficult • You can write it in a language implemented by an assembler or compiler on another computer, but: • You have to another computer with this software • You end up with an assembler that runs on the other computer, not yours CS 100 - Lecture 11

  42. Bootstrapping • This sort of problem can be solved by “bootstrapping” • Program the first version of the assembler in itself • Hand translate this program to machine language • Run and debug it, but correct errors in both the machine language and assembly language versions • Once it is debugged, it ought to be able to assemble itself • You can throw away the ML version, and from now on edit the AL version • New assembler version is always assembled by the previous version CS 100 - Lecture 11

  43. Translating Assembly Language Program into Machine Language • Four basic tasks performed by assembler: • Convert symbolic op codes and addresses to binary • Do pseudo-ops • Write machine language program to file • Assembler does this in two passes • Pass 1: Build symbol table that maps labels to addresses; this will enable us to translate those labels to actual addresses in the second pass CS 100 - Lecture 11 (slide < C. Hundhausen)

  44. Translating Assembly Language (2) • Pass 2: Create machine language object file Open new object file Get first Assembly language instruction While the instruction is not .END If instruction is .DATA Create binary value corresponding to value in address field Store the value in object file with address where to load it Else Look up the op code of the instruction Get binary value of op code Look up address field in symbol table Build machine language instruction and write to object file Endif Get next instruction EndWhile CS 100 - Lecture 11 (slide adapt. < C. Hundhausen)

More Related