Intel Assembler Intro

Assembler Programming Introduction

At this juncture, we will dive into Intel assembler and learn a bit how to program at that level.
Though assembler programming is (in part) an exercise in life without a compiler, we still need an assembler
these notes will assume you are working on a Unix-based system; examples in class will use Linux's nasm assembler
if you intend to use a Windows system, you should skip over to this version of the notes
As to the language itself, the basics consist of bookends, registers, and instructions.

a typical start (front bookend) and finish (ending bookend) for an Intel assembler program looks like this:

segment .text
  global main
main:
  push ebp
  mov ebp, esp


  ; something interesting happens here


  mov eax, 0
  mov esp, ebp
  pop ebp
  ret

main, of course, has the same role as it would for a Java or C program
note the semi-colon is used to start a comment and anything to the right of it is discarded by the assembler
the reference "segment .text" indicates the beginning of instructions (as opposed to data, which has a different segment header)
as for the pushing and popping, let's draw out the stack to get a better idea of what is really happening
to compile this on cs3, unfortunately, it requires multiple steps
let's say this code was in a file named first.s (note the .s is used in Unix; Windows uses .asm)
to compile and run this program, we would do the following:
```
nasm -f elf
gcc first.o
./a.out
```

let's try this same template, but add in some data and a little arithmetic

segment .data
  num1 dd 3
  num2 dd 5
  num3 dd 7

segment .text
  global main
main:
  push ebp
  mov ebp, esp

  ; do the adding using eax as a running total
  mov eax, [num1]  ; brackets say "I want the value stored at label num1"
  add eax, [num2]
  add eax, [num3]

  mov eax, 0
  mov esp, ebp
  pop ebp
  ret

to declare something, we need a data segment
inside it, an integer is declared using the pseudo-command "dd"; the first d indicates data and the second d stands for double-word or 32 bits
to "assign" a value to a register or variable, use the mov assembler instruction, but note the first operand is the destination, not the second
the code above shows how to take the value of a variable (must use brackets) and assign it to a register
to assign a variable with a value in a register, put the variable as the first operand: mov [num1], eax
to print a value, we'll use the printf routine built into the Unix programming environment

Here's a hello world program:

extern printf

segment .data
  mymessage db "hello world",10,0

segment .text
  global main
main:
  push ebp
  mov ebp, esp

  push mymessage  ; put the string on the stack as a parameter to printf
  call printf
  add esp, 4      ; restore stack to before we did the push

  mov eax, 0
  mov esp, ebp
  pop ebp
  ret

note that characters use the "db" pseudo-command (d for data, b for byte) instead of "dd"
also note how we push the address (not the value) of the string onto the stack as an argument to printf
the add to esp afterward resets the stack pointer to where it was before we pushed the argument (could have done a pop, but didn't need to save the value)
the 10 after "hello world" represents the newline character ("\n") and the 0 is the C-style way of indicating the end of the string

Registers and Arithmetic

Intel chips have 16 named registers (ten 32-bit and six 16-bit), but our programs typically only use three or four
The 32-bit registers named eax, ebx, ecx, and edx are the workhorses for Intel assembler programs.
We can refer to the lower-order 16 bits of each of these by dropping the 'e'. For example, ax is a 16-bit register.
This goes one more step and replacing the 'x' with 'l' (the letter "el") refers to the lowest 8 bits. Thus al is an 8-bit register.
Replacing the 'x' with 'h' refers to the higher-order 8 bits of the 'x' register, e.g. ah and al are the two halves of ax.
Intel chip sports all sorts of instructions. Our goal is to become familiar with a handful.
To do basic math, Intel has instructions "add", "sub", "mul", and "div".

if we combine the last two programs to add three numbers and print the result we get this

extern printf

segment .data
  patt db "sum=%d",10,0
  num1 dd 3
  num2 dd 5
  num3 dd 7

segment .text
  global main
main:
  push ebp
  mov ebp, esp

  mov eax, [num1]
  add eax, [num2]
  add eax, [num3]
  push eax
  push patt
  call printf
  add esp, 8

  mov eax, 0
  mov esp, ebp
  pop ebp
  ret

the variable patt is initialized as a pattern for what will be printed and the %d is where the value of the sum will be inserted (this follows the pattern for printf)
again note the push statements for the two arguments for printf and the add afterwards resets the stack pointer
For multiply and divide, "mul" and "div" are for unsigned numbers and "imul" and "idiv" for signed numbers.
the multiply and divide instructions have an implicit operand
- when multiplying the given operand is multiplied implicitly with eax and the result is spread over two registers edx and eax (sometimes shown as edx:eax)
- when dividing the given operand is the denominator and the numerator is implicitly edx:eax
- the result for division is placed in eax and the remainder is placed in edx

here is an example that uses all four arithmetic operations

; compute and print y = (x - 1) * (x - 5) / (x - 11) where x = 9
; answer should be -16

extern printf

segment .data
  resultmsg db "y=%d",10,0
  x dd 9
  y dd 0

segment .text
  global main
main:
  push ebp
  mov ebp, esp

  mov eax, [x]       ; eax = x
  mov ebx, eax       ; ebx = eax = x
  mov ecx, eax       ; ecx = eax = x (now we have three copies of x)
  sub eax, 1         ; eax = eax - 1 = x - 1
  sub ebx, 5         ; ebx = ebx - 5 = x - 5
  sub ecx, 11        ; ecx = ecx - 11 = x - 11
  imul ebx           ; edx:eax = eax * ebx
  idiv ecx           ; eax = edx:eax / ecx (edx gets the remainder)
  mov [y], eax

  push dword [y]
  push resultmsg
  call printf
  add esp, 8

  mov eax, 0
  mov esp, ebp
  pop ebp
  ret

Practice#1: translate this into assembler [solution]
```
y = (a + b) * (a - b) / c
```
where a = 17, b = -3, and c = 7.