1 / 56

Assembling and Linking

Assembling and Linking. An assembly language program is turned into an executable file in two steps Assembling turns the source code into object code (.obj file) – an intermediate and inexact form of machine code Linking turns the object code into an executable form (.exe file)

treva
Télécharger la présentation

Assembling and Linking

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. Assembling and Linking • An assembly language program is turned into an executable file in two steps • Assembling turns the source code into object code (.obj file) – an intermediate and inexact form of machine code • Linking turns the object code into an executable form (.exe file) • The code in two executables can’t be combined, but the code in two object files can

  2. The Debugger • Contrary to the name, it is not only for debugging • Debugging assembly language programs can help the programmer understand the CPU’s inner-workings • Many people advocate stepping through every program, assembly language or not

  3. The “Moving” Example • Pages 82-83 • Demonstration of assembling, linking, and debugging steps • Common mistakes • Trying to operate on two operands of differing sizes • Using the label rather than the memory it labels • The offset keyword

  4. Comments on Comments • In assembly language, comments start with a semicolon • Comments used with properly-inserted blank lines can make for a very readable program • Comments should also be used to explain confusing instructions

  5. The Stack • A stack is like a spring-loaded bin of dishes in a cafeteria • Only the top is readily available • Placing a dish is called a push • Taking a dish is called a pop • A stack is known as a LIFO structure (last in, first out)

  6. The Stack (cont.) • A computer doesn’t actually move bytes up and down, but keeps track of the top of the stack with the stack pointer (8086 pointer register sp) • The assembly language instructions push and pop directly manipulate the current program’s stack • Every push in a program should have a balancing pop • One of the best uses of the stack is to save the values in the registers • The stack demo (pages 86-87)

  7. The Flags • The flags register keeps information on the state of the CPU • Most arithmetic and bitwise instructions have some effect on the flags register • The boolean values in the flags register affect the results of some instructions • The flags register is also used in conditional program flow (e.g. decision-making, loops)

  8. Addition Instructions • Common addition instructions: add dest, source adc dest, source • If an add (or adc) instruction overflows, the would-be last bit (bit 8 for a byte, or bit 16 for a word) is stored in the carry flag • The adc instruction adds like add, but adds the carry flag to the first bit (bit 0)

  9. Addition Instructions (cont.) • add and adc can be used together to add very large integers: ; number1 and number2 are ; defined as DD above mov ax, [word number1] mov dx, [word number1 + 2] add ax, [word number2] adc dx, [word number2 + 2]

  10. Subtraction Instructions • Common subtraction instructions: sub dest, source sbb dest, source • If a sub (or sbb) instruction borrows from a nonexistent bit (bit 8 for a byte, or bit 16 for a word), the carry flag is set • The sbb instruction subtracts like sub, but acts like bit 0 was borrowed from if the carry flag is set

  11. Subtraction Instructions (cont.) • sub and sbb can be used together to subtract very large integers: ; number1 and number2 are ; defined as DD above mov ax, [word number1] mov dx, [word number1 + 2] sub ax, [word number2] sbb dx, [word number2 + 2]

  12. Multiplication Instructions • Common multiplication instructions: mul source imul source • The destination is always understood to be the ax register (using dx as overflow) or the al register (using ah as overflow)

  13. Division Instructions • Common division instructions: div source idiv source • The destination is always understood to be the ax register or the ax and dx registers • If the source is 8-bit, • the destination is the ax register • the result is put in the al register, with the remainder in ah • If the source is 16-bit, • the destination is the ax and dx registers • the result is put in the ax register, with the remainder in dx

  14. Signed Arithmetic • Addition and subtraction work the same way regardless of sign • imul and idiv treat operands as signed values; mul and div assume all values are unsigned • Sometimes, for imul and idiv, it is necessary to convert from 8 bits to 16, or from 16 to 32

  15. Signed Arithmetic (cont.) • Just setting high-order bits to zero will not work when using two’s complement • cbw (convert byte to word) and cwd (convert word to doubleword) exist for conversion • cbw assumes the byte to be converted is in al and extends the sign bit through ah • cwd assumes the word to be converted is in ax and extends the sign bit through dx

  16. Bitwise Instructions • The text calls them logic instructions • Common bitwise instructions: and dest, source not dest or dest, source test dest, source xor dest, source rcl dest, source rcr dest, source rol dest, source ror dest, source sar dest, source shl/sal dest, source shr dest, source

  17. Bitwise Instructions (cont.) • and, or, xor, and not should be intuitive • All but not operate on a destination and source operands, and leave the result in the destination operand • not operates on the destination, and leaves the result in the destination • test • performs a logical and on the destination and source, and throws away the result • sets the zero flag if the result is zero, and clears it if it isn’t

  18. Shift Instructions • Shifts can be grouped into four groups • Plain shifts (shl, shr) • Plain rotations (rol, ror) • Rotations through the carry flag (rcl, rcr) • Arithmetic shifts (sal, sar) • They each require the same operands, but have subtle differences

  19. Shift Instructions (cont.) • Common syntax: shl ax, 1 shl bh, cl shl [number], 1 shl [number], cl • If the source is a constant, it must be 1 • If the destination is to be shifted any more than one place, the source must be the register cl only • If the processor is an 80386 or later, the source may be an 8-bit constant

  20. Shifting Instructions • Page 107 in the text • The shift instructions (shl, shr) move a zero value into the empty bit, and put what was shifted out into the carry flag

  21. Rotate-through-carry Instructions • Page 108 in the text • The rotate-through-carry instructions (rcl, rcr) move the carry flag into the empty bit, and put what was shifted out into the carry flag • These can be combined with shifting instructions to shift very large integers

  22. Rotate-through-carry Instructions (cont.) • This will only work shifting bits one position at a time ; number1 is defined as DD above ; this multiplies it by two mov ax, [word number1] mov dx, [word number1 + 2] shl ax, 1 rcl dx, 1

  23. Rotation Instructions • Page 107 in the text • rol shifts all bits left, moving the MSD into the LSD and also into the carry flag • ror shifts all bits right, moving the LSD into the MSD and also into the carry flag • Rotating the same number of places as there are bits will return the same number • Rotation instructions are usually of less practical value than the other shift instructions

  24. Arithmetic Shifts • Page 108 in the text • Shifting a negative (in two’s complement) number right using shr will not divide the number by two properly • sar copies the old MSD into the new MSD, preserving the sign bit • sal is the same as shl

  25. Flow Control • Assembly language (and machine code, for that matter) lacks certain elements we take for granted in higher-level languages: • for (<initializer>; <condition>; <increment>)… • while (<expression>)… • do…while (<expression>) • if (<expression>)…else if (<expression>)…else… • <function>(<parameter>,…) • Expressions and flow-control structures

  26. Flow Control (cont.) • Instructions that allow non-sequential execution are called transfer or jump instructions • All work by changing the ip register (or, sometimes, cs:ip) under certain circumstances • Unconditional transfer instructions jump under any circumstances • Conditional transfer instructions jump when certain flags are set or cleared

  27. Flow Control (cont.) • Three types of transfers • Subroutine (opcodes call, int) – these can be returned from, and are unconditional • Jump (opcode jmp) – these cannot be returned from, and are unconditional • Conditional jump (many opcodes)

  28. Subroutines • The call instruction is one of two transfer instructions that may be returned from • call • pushes the address of the instruction after it onto the stack (or cs:<address>) • changes ip to be the address of the function that is being called (or cs:ip) • ret • pops ip from the top of the stack (or cs:ip)

  29. Subroutines (cont.) • Example program – page 113 • Any subroutine should either: • document which registers it destroys • save all registers it uses on the stack • Subroutines should: • be as short as possible • be only as long as necessary • accomplish one simple task

  30. PROC and ENDP • Are compiler directives, and are optional (except in this class) • Mark the beginning and end of a subroutine • Should each be followed by the name (or label) of the subroutine

  31. NEAR and FAR • A near, or intrasegment call is one to the same code segment • A far, or intersegment call is one to a different code segment • There is only one call opcode, but two return opcodes – retn and retf • The opcode ret is translated into either retn or retf • A subroutine can be made explicitly near or far with the directives NEAR and FAR

  32. Passing Values • There are three common methods for passing values to a subroutine: • Storing parameters in registers (like in AddRegisters) • Storing data in global variables (in the data segment) • Passing data on the stack • Choosing the second option is generally bad – if two subroutines use the same global variables, things could get ugly very fast

  33. Passing Values (cont.) • The first option (registers) is extremely common, fast, and very workable • The third option (stack) is best for working with many parameters • Most high-level languages pass parameters to functions (or methods) on the stack

  34. Passing Values (cont.) This will not work: mov ax, 1 push ax mov ax, 2 push ax mov ax, 3 push ax mov ax, 4 push ax call AddValues PROC AddValues pop dx pop cx pop bx pop ax . . ret ENDP AddValues

  35. Passing Values (cont.) This will work: PROC AddValues pop si pop dx pop cx pop bx pop ax push si . . ret ENDP AddValues mov ax, 1 push ax mov ax, 2 push ax mov ax, 3 push ax mov ax, 4 push ax call AddValues

  36. I’m SAVED! • Who should save the registers’ values? • The subroutine? • The caller? • Each method has its own strengths and weaknesses

  37. Saving Private Registers versus push bx push cx call AddRegisters pop cx pop bx PROC AddRegisters push bx push cx . . pop cx pop bx ret ENDP AddRegisters

  38. Goto, er, Jump • Assembly language has one unconditional jump instruction – jmp • jmp works exactly the same way as call, except it doesn’t push the address of the instruction after it onto the stack • Syntax: jmp label • A jump may be near or far, depending on which code segment the label is in • Use it as little as possible

  39. Goto-if (Conditional Jumps) • Many instructions affect the flags register • Conditional jump instructions decide whether to jump or fall through based on the contents of the flags register • Consider the following: mov cx, 5 ; 5 -> cx Back: add ax, bx ; ax = ax + bx dec cx jnz Back ; while cx != 0

  40. Comparison == Subtraction? • The cmp command is listed as a subtraction instruction on page 91 • Why? • sub instruction sets flags, but changes registers • cmp subtracts like sub, but doesn’t change registers • The flags can be tested after a cmp to find out how the two operands are related

  41. Equal Equals Zero • Consider the following: PROC RegEqual mov cx, 1 ; Preset cx to 1 cmp ax, bx ; Compare ax and bx je Continue ; Jump if ax == bx xor cx, cx ; Otherwise, set cx to 0 Continue: ret ; Return to caller ENDP RegEqual

  42. Endings for Relationships • Useful relationships • op1 greater than op2? • op1 equal to op2? • op1 less than op2? • All conditional jump instructions start with the letter j and end with letters that match a relationship • Page 121 contains a list of useful conditional jump endings • above and below versus greater and less

  43. Seeing in Double • Some conditional jump endings are synonymous: • jz is the same as je • jge is the same as jnl • Conditional jump synonyms are translated into the same machine code • They exist only for clarity

  44. Destination Restrictions • The jmp and call instructions may direct program flow to anywhere in memory (near or far) • Conditional jump instructions may only go 128 bytes back or 127 bytes forward • When the destination is out of reach, reverse the condition and add an unconditional jump

  45. Flag Operations • Some instructions exist only to modify the flags register • Carry flag instructions: • stc – sets the carry flag • clc – clears the carry flag • cmc – complements (toggles) the carry flag • Direction flag instructions: • std – sets the direction flag • cld – clears the direction flag • used only for string instructions (covered later)

  46. Flag Operations (cont.) • Interrupt flag instructions: • sti – sets the interrupt flag • cli – clears the interrupt flag • Carry flag instructions are commonly used to pass information back from subroutines, or indicate that an error occurred

  47. Carry Flag mov dl, [value] call TestBit jc BitIsSet . . PROC TestBit clc test dl, 08h jz Exit stc Exit: ret ENDP TestBit

  48. String Operations • “Strings” in assembly language are actually any contiguous group of bytes of any length • The 8086 CPU provides instructions that • Transfer strings • Inspect strings • All string instructions have common traits

  49. String Instruction Commonalities • All operations that act on a source string (loading, copying, comparing) expect the source string to be at ds:si • All operations that act on a destination string (storing, copying, comparing) expect the destination string to be at es:di • All string operations increment or decrement si, di, or both • String operations increment when the direction flag is clear and decrement when it is set • All string operations can be prefixed with a repeat modifier

  50. String Load Example • Consider the following: mov si, offset words ; Get the address ; of the string cld ; Go forward Repeat: lods [word ptr ds:si] ; ds:si -> ax, cmp ax, 0 ; si++ jne Repeat

More Related