Assembly and Assemblers

• A compiler translates from a high level language into machine language
  • This is a multistep process for C++.
  • The preprocessor directives are handled by the preprocessor
  • The compiler proper rewrites the high level language into intermediate code.
  • The optimizer will make the intermediate code more efficient for a given architecture.
  • The code generator will produce object code in the target machine language
  • The linker will combine the object code with libraries to produce an executable.
• At the assembly level things are much more simple.
  • Assembly language tends to be very close to machine language.
  • The assembler produces object files
  • The linker combines the object code with libraries to produce an executable.
• The assembler provides several services.
  • Translation from Assembly to Machine Language
  • Example: Addi
    • Assembly instruction: addi $t1, $zero, 100
    • Action: Add the 100₁₀ to the contents of register zero and store the result in register t1.
    • Looking at the green sheet, we see ADDI is a I type instruction.
    • Looking at the green sheet, we see that an I type instruction has
    • op code bits 31 to 26, in this case 8₁₆
    • or 001000₂ or 08₁₆
    • Looking at the table on page 78, we see that addi has the format
    • addi $s1, $s2, immediate
    • And performs $s1 = $s2 + immediate
    • Looking at the green sheet we see
    • Add performs R[rt] = R[rs] + Signed Immediate
    • We can conclude that rt is $t1 and $zero is $rs
    • Looking at the green sheet we see that rs takes up bits 21 through 25 (5)
    • Looking at the lower right hand side of the green sheet, we see $zero is register 0, or 00000₂
    • Encode rt in the same way
    • Looking at the lower right hand side of the green sheet, we see $t1 is register 9, or 01001₂
    • 100 is 64₁₆ or 1100100
    • Putting it together we find the code should be

    •   08     0     9        0064
      001000 00000 01001 0000000001100100
                 or
      0010 0000 0000 1001 0000 0000 0110 0100
       2    0    0    9    0    0    6    4
      

  • Try beq $t5, $a2,-32
    • Opcode: 4₁₆
    • RS: $t5: 13-> D₁₆
    • RT: $a2: 6 -> 6₁₆
    • imm: -32 -> FFE0₁₆

        4     13     6     F   F     E   0
      000100 01101 00110 1111 1111 1110 0000
      0001 0001 1010 0110 1111 1111 1110 0000
        1    1   A    6    F    F   E  0
      	   

  • Try add $t8, $s1, $a0
    • The R type instruction is different, it has an op code and a function code.
      Add has an opcode of 0 and a function code of 20₁₆
      • Set shift to 0 for now.
      • Page 78: s1 = s2 + s3 <-> addi $s1, $s2, $s3
      • RD: $t8: 24 -> 18₁₆
      • RS: $s1: 17 -> 11₁₆
      • RT: $a0: 4 -> 04₁₆
  • The assembler also handles labels
    • Position of data in memory
    • Position of an instruction in memory.
    • To do this, it builds a symbol table.
    • Assemblers can be one pass or two pass.
    • This is an association of the label with an address.
    • In the future, when the label is encountered, a proper address can be calculated.
    • This is important because most references to memory are offsets.
  • An assembler also handles pseudo-ops or macros.
    • Try li $t5, 100
    • move $t0, $t3
    • See MARS on-line help
  • The assembler handles assembler directives.
    • .data
    • .text
    • .word, .ascii, asciiz, .space
    • See MARS on-line help
  • Linking to external libraries
• System calls
  • Based on the value in $v0
  • If there are arguments, they are stuck in $a0 through $a2 or $f12
  • issue syscall
  • If there is a return, it will immediately follow the syscall