1 / 37

Assembly Language

Assembly Language. Part 3. Symbols. Symbols are assembler names for memory addresses Can be used to label data or instructions Syntax rules: start with letter contain letter & digits 8 characters max CASE sensitive Define by placing symbol label at start of line, followed by colon.

amable
Download Presentation

Assembly Language

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. Assembly Language Part 3

  2. Symbols • Symbols are assembler names for memory addresses • Can be used to label data or instructions • Syntax rules: • start with letter • contain letter & digits • 8 characters max • CASE sensitive • Define by placing symbol label at start of line, followed by colon

  3. Symbol Table • Assembler stores labels & corresponding addresses in lookup table called symbol table • Value of symbol corresponds to 1st byte of memory address (of data or instruction) • Symbol table only stores label & address, not nature of what is stored • Instruction can still be interpreted as data, & vice versa

  4. Example Example program: this: deco this, d stop .end Output: 14592 What happened?

  5. High Level Languages & Compilers • Compilers translate high level language code into low level language; may be: • machine language • assembly language • for the latter an additional translation step is required to make the program executable

  6. C++/Java example // Java code: public class Hello { static String greeting = “Hello world”; public static void main (String [] args) { System.out.print (greeting); System.out.print(‘\n’); } } // C++ code: #include <iostream.h> #include <string> string greeting = “Hello world”; int main () { cout << greeting << endl; return 0; }

  7. Assembly language (approximate) equivalent br main greeting: .ASCII "Hello world \x00" main: stro greeting, d charo '\n', i stop .end

  8. Data types • In a high level language, such as Java or C++, variables have the following characteristics: • Name • Value • Data Type • At a lower level (assembly or machine language), a variable is just a memory location • The compiler generates a symbol table to keep track of high level language variables

  9. Symbol table entries • The illustration drove shows a snippet of output from the Pep/8 assembler. Each symbol table entry includes: • the symbol • the value (of the symbol’s start address) • the type (.ASCII in this case)

  10. Pep/8 Branching instructions • We have already seen the use of BR, the unconditional branch instruction • Pep/8 also includes 8 conditional branch instructions; these are used to create assembly language control structures • These instructions are described on the next couple of slides

  11. Conditional branching instructions • BRLE: • branch on less than or equal • how it works: if N or Z is 1, PC = operand • BRLT: • branch on less than • how it works: if N is 1, PC = operand • BREQ: • branch on equal • how it works: if Z is 1, PC = operand • BRNE: • branch on not equal • how it works: if Z is 0, PC = operand

  12. Conditional branching instructions • BRGE: • branch on greater than or equal • if N is 0, PC = operand • BRGT: • branch on greater than • if N and Z are 0, PC = operand • BRV: • branch if overflow • if V is 1, PC = operand • BRC: • branch if carry • if C is 1, PC = operand

  13. Example Pep/8 code: br main num: .block 2 prompt: .ascii "Enter a number: \x00" main: stro prompt, d deci num, d lda num, d brge endif lda num, d nega ; negate value in a sta num, d endif: deco num, d stop .end HLL code: int num; Scanner kb = new Scanner(); System.out.print (“Enter a number: ”); num = kb.nextInt(); if (num < 0) num = -num; System.out.print(num);

  14. Analysis of example Pep/8 code: br main num: .block 2 prompt: .ascii "Enter a number: \x00" main: stro prompt, d deci num, d lda num, d brge endif lda num, d nega ; negate value in a sta num, d endif: deco num, d stop .end The if statement, if translated back to Java, would now be more like: if (num >= 0); else num = -num; This part requires a little more explanation; see next slide

  15. Analysis continued • A compiler must be programmed to translate assignment statements; a reasonable translation of x = 3 might be: • load a value into the accumulator • evaluate the expression • store result to variable • In the case above (and in the assembly language code on the previous page), evaluation of the expression isn’t necessary, since the initial value loaded into A is the only value involved (the second load is really the evaluation of the expression)

  16. Compiler types and efficiency • An optimizing compiler would perform the necessary source code analysis to recognize that the second load is extraneous • advantage: end product (executable code) is shorter & faster • disadvantage: takes longer to compile • So, an optimizing compiler is good for producing the end product, or a product that will be executed many times (for testing); a non-optimizing compiler, because it does the translation quickly, is better for mid-development

  17. Another example HLL code: final int limit = 100; int num; System.out.print(“Enter a #: ”); if (num >= limit) System.out.print(“high”); else System.out.print(“low”); Pep/8 code: br main limit: .equate 100 num: .block 2 high: .ascii "high\x00" low: .ascii "low\x00" prompt: .ascii "Enter a #: \x00" main: stro prompt, d deci num, d if: lda num, d cpa limit, i brlt else stro high, d br endif else: stro low, d endif: stop .end Compare instruction: cpr where r is a register (a or x): action same as subr except difference (result) isn’t stored in the register – just sets status bits – if N or Z is 0, <= is true

  18. Writing loops in assembly language • As we have seen, an if or if/else structure in assembly language involves a comparison and then a (possible) branch forward to another section of code • A loop structure is actually more like its high level language equivalent; for a while loop, the algorithm is: • perform comparison; branch forward if condition isn’t met (loop ends) • otherwise, perform statements in loop body • perform unconditional branch back to comparison

  19. Example • The following example shows a C++ program (because this is easier to demonstrate in C++ than in Java) that performs the following algorithm: • prompt for input (of a string) • read one character • while (character != end character (‘*’)) • write out character • read next character

  20. C++ code #include <iostream.h> int main () { char ch; cout << “Enter a line of text, ending with *” << endl; cin.get (ch); while (ch != ‘*’) { cout << ch; cin.get(ch); } return 0; }

  21. Pep/8 code ;am3ex5 br main ch: .block 1 prompt: .ascii "Enter a line of text ending with *\n\x00" main: stro prompt, d chari ch, d ; initial read lda 0x0000, i ; clear accumulator while: ldbytea ch, d ; load ch into A cpa '*', i breq endW charo ch, d chari ch, d ; read next letter br while endW: stop .end

  22. Do/while loop • Post-test loop: condition test occurs after iteration • Premise of sample program: • cop is sitting at a speed trap • speeder drives by • within 2 seconds, cop starts following, going 5 meters/second faster • how far does the cop travel before catching up with the speeder?

  23. C++ version of speedtrap #include <iostream.h> #include <stdlib.h> int main() { int copDistance = 0; // cop is sitting still int speeder; // speeder's speed: entered by user int speederDistance; // distance speeder travels from cop’s position cout << "How fast is the driver going? (Enter whole #): "; cin >> speeder; speederDistance = speeder; do { copDistance += speeder + 5; speederDistance += speeder; } while (copDistance < speederDistance); cout << "Cop catches up to speeder in " << copDistance << " meters." << endl; return 0; }

  24. Pep/8 version ;speedTrap br main cop: .block 2 drvspd: .block 2 drvpos: .block 2 prompt: .ascii "How fast is the driver going? (Enter whole #): \x00" outpt1: .ascii "Cop catches up to speeder in \x00" outpt2: .ascii " meters\n\x00" main: lda 0, i sta cop, d stro prompt, d deci drvspd, d ; cin >> speeder; ldx drvspd, d ; speederDistance = speeder; stx drvpos, d

  25. Pep/8 version continued do: lda 5, i ; copDistance += speeder + 5; adda drvspd, d adda cop, d sta cop, d addx drvspd, d ; speederDistance += speeder; stx drvpos, d while: lda cop, d ; while (copDistance < cpa drvpos, d ; speederDistance); brlt do stro outpt1, d deco cop, d stro outpt2, d stop .end

  26. For loops • For loop is just a count-controlled while loop • Next example illustrates nested for loops

  27. C++ version #include <iostream.h> #include <stdlib.h> int main() { int x,y; for (x=0; x < 4; x++) { for (y = x; y > 0; y--) cout << "* "; cout << endl; } return 0; }

  28. Pep/8 version ;nestfor br main x: .word 0x0000 y: .word 0x0000 main: sta x, d stx y, d outer: adda 1, i cpa 5, i breq endo sta x, d ldx x, d inner: charo '*', i charo ' ', i subx 1, i cpx 0, i brne inner charo '\n', i br outer endo: stop .end

  29. Notes on control structures • It’s possible to create “control structures” in assembly language that don’t exist at a higher level • Your text describes such a structure, illustrated and explained on the next slide

  30. A control structure not found in nature • Condition C1 is tested; if true, branch to middle of loop (S3) • After S3 (however you happen to get there – via branch from C1 or sequentially, from S2) test C2 • If C2 is true, branch to top of loop • No way to do this in C++ or Java (at least, not without the dreaded goto statement)

  31. High level language programs vs. assembly language programs • If you’re talking about pure speed, a program in assembly language will almost always beat one that originated in a high level language • Assembly and machine language programs produced by a compiler are almost always longer and slower • So why use high level languages (besides the fact that assembly language is a pain in the patoot)

  32. Why high level languages? • Type checking: • data types sort of exist at low level, but the assembler doesn’t check your syntax to ensure you’re using them correctly • can attempt to DECO a string, for example • Encourages structured programming

  33. Structured programming • Flow of control in program is limited to nestings of if/else, switch, while, do/while and for statements • Overuse of branching instructions leads to spaghetti code

  34. Unstructured branching • Advantage: can lead to faster, smaller programs • Disadvantage: Difficult to understand • and debug • and maintain • and modify • Structured flow of control is newer idea than branching; a form of branching with gotos by another name lives on in the Java/C++ switch/case structure

  35. Evolution of structured programming • First widespread high level language was FORTRAN; it introduced a new conditional branch statement: if (expression) GOTO new location • Considered improvement over assembly language – combined CPr and BR statements • Still used opposite logic: if (expression not true) branch else // if-related statements here branch past else else: // else-related statements here destination for if branch

  36. Block-structured languages • ALGOL-60 (introduced in 1960 – hey, me too) featured first use of program blocks for selection/iteration structures • Descendants of ALGOL include C, C++, and Java

  37. Structured Programming Theorem • Any algorithm containing GOTOs can be written using only nested ifs and while loops (proven back in 1966) • In 1968, Edsgar Dijkstra wrote a famous letter to the editor of Communications of the ACM entitled “gotos considered harmful” – considered the structured programming manifesto • It turns out that structured code is less expensive to develop, debug and maintain than unstructured code – even factoring in the cost of additional memory requirements and execution time

More Related