CSC 2210, Note 4: Assembly

CSC 2210 Note 4: Assembly Programming for the x86 family

History

Material from x86 Assembly text
First processor in the line: 8086 (1978) - visit page for image of the processor; scroll down for more detail
16 bit processor, 29,000 transistors
Floating point arithmetic done on a separate processor, the 8087
Could be configured to address 1MiB - that is, 20 bit addresses
80386 (1985): 32-bit word
Core, Core 2 (2006), i Series (2008): 64-bit processors (x64)
8086 registers: AX, BX, CX, DX, SP, BP, SI, DI
- AX, BX, CX, DX: general purpose (but with restrictions)
- Each of AX, BX, CX, DX: also could be addressed as high/low half: AH, AL, etc.
- SP: stack pointer
- BP: "stack base pointer" - points to start of data for current function/procedure
- SI, DI: source, destination index: used for array operations
- Yup, this is a mess! But they had only a handful of resisters to work with...
- Worse, supporting 20-bit addresses was done by adding "segment" registers: SS (stack), CS (code), DS (data), ES (extra), FS, GS - we won't use these
32-bit registers - the default state for the code we'll write
- EAX, EBX, ECX, EDX
  - "E" means "extended"
  - These overlap AX, BX, CX, DX, but add more bits
- ESP, EBP: extended stack, stack base pointers
- ESI, EDI: again, for processing arrays
64-bit registers: same as 32, but replace E by R (RAX, RBX, etc.)
- 64-bit also adds more general purpose, 64-bit registers: R8-R15

Some First Assembly Code

Visit Online GCC Assembler (with apologies for the adds!)
- Run default code
- This is GAS - GNU Assembly (and what is produced by G++ on Windows)
- xor %eax, %eax: set eax to 0 - more discussion later
- Why %eax? This is the Intel convention for return values from functions
Implement (from here):
- mov $4, %eax
- mov: copy data to destination - calling it move is "traditional"
- general form: instruction source, destination
  - Intel version: mov eax, 4: destination is first!
- %: signal a register name (as opposed to an address named "eax", for instance)
- $: signal an immediate value - the value is stored in the instruction
Add 38, because we know 42 is the answer: add $38, %eax
Better, do the computation in %ebx because it shows in the debugger
- set breakpoint at first mov statement, click Debug and then start
- change code to compute to %ebx (without mov to %eax) and then re-run debugger
- Note result is random; move %ebx to %eax
set %ebx to 1, add neg %ebx, step through
- Computes 2s complement
use and, or, xor, not with 01101100 (0x6C) and 01110101 (0x75)
- C, C++, Java way to do these: &, |, ↑, ~
- For example: unsigned int result = 0x6c & 0x75;
- What is xor, and what do we get with xor %eax, %eax?
  - xor takes 2 bytes, mov $0, %eax needs 4 bytes for the 0 (for a total of 5 bytes)
  - Smaller is slightly faster...
- Signed multiplication: imul, but there's a twist..
  - with just one argument, always multiplying by %eax
  - Result alwaysin %eax (low order bits), %edx (high order bits)
  - mov $6, %eax, then mov $9, %ebx, and mul %ebx
  - Why %edx? can always double the significant bits
- Signed multiplication, specifying both values:
```
        mov $5, %ebx
        mov $6, %ecx
        imul %ecx, %ebx
```
  In this case there is no implicit side-effect modifying %eax or %edx
Exercise: suppose a = %eax, etc; compute a² + bc + d into %eax
- need push, pop
What are the other lines?
- .data: data segment (currently empty)
- .text: code segment (name text likely comes from it being the text of the program in the same way that the lyrics are the words (text) of a song
  - But don't site this! There are long discussions about where the word comes from...
- .global: signals that it can be called from other "modules"
- main: a label indicating the start of a routine (here, the main function of the program)
- ret: return instruction - return to caller

C++ programs with embedded assembly

We could write full programs in assembly
Challenge: they would be long, and lots of code would be about input and output
Our solution: use the __asm__ keyword
See simp_asm_fun_call.cpp

A note on sizes

Many x86 instructions can work on multiple types of data
The type can typically be inferred from the size of the registers involved: mov $5, %eax will set a 32-bit register, so can assume to be moving a "long"
Move has a movX variant where X is b, w, l, q
- movb: 8 bits; movw: 16 bits (a word on a 16-bit machine); movl: 32 bits; movq: 64 bits (quadword)
An assembler might support similar suffixes for other operations such as add
This was an ill-fated attempt to add types to assembly!
Given the disconnect between the names and actual machine word sizes, avoid the longer names - they just violate the write once principle
You will often see this size information in "disassembled" code.

Review

x86 family history
x86 registers (8 bit through 64 bit)
basic math: add, neg
basic logic: bitwise and, or, xor, not; logical operations
straight-line assembly programs