ASSEMBLY NOTES

Machine code is the binary representation of the instructions executed directly by the CPU. One level of abstraction above that is assembly language. Assembly language is specific to the CPU architecture. It typically uses mnemonic opcodes to represent operations, such as MOV, ADD, etc.

This refers to the 64-bit extension of the x86 instruction set developed for intel processors. x86-64 was introduced in 1999 is the most widely used assembly language for desktops, laptops and servers at time of writing (2024). It supports 64-bit registers, unlike the 32-bit registers for the preceding IA-32 architecture.

The CPU can temporarily store data in registers. They are the fastest storage in the computer (faster than cache or RAM for example) and they are limited in size and count. Some registers are specialised such as the Instruction Pointer which holds the address of the next instruction, or the Stack Pointer which points to the current top of the stack in memory. Others are general purpose.

Address space is the number of addresses in memory that the CPU can access in a single operation. for 64-bit CPUs this is 2⁶⁴ addresses.

• 64-bit registers
• Larger address space
• backwards compatibility with 32-bit x68 programs.
• New instructions
• More general purpose registers
• SMID extensions (single instruction, multiple data).

We will get into what some of these registers do below.

An assembly program has the following three sections: Data, BSS, Text.

The assembler is a program converts assembly code into machine language (binary). The output file is known as an object file, hence the .o suffix. During this process the variable names get removed and converted into addresses.

Also known as the linkage editor. This combines object files into a single executable. It also includes any libraries required for execution. The following is a command for the GNU Gold linker:

ld -g -o example example.o

The -g flag tells the linker to include debugging information. The -o flag specifies the output file, here example. Multiple object files can be linked together. When using a function from another file, the function must be flagged with extern.

This is the part of the operating system that loads the program from secondary storage into memory. Under Linux this is done with the program name. For example, if the program is called hello_world, the command will be:

./hello_world

This is a program that can control the execution of the assembly program in order to inspect how it is (or is not) working.

In a segmented memory model the system memory is divided into independent segments. Segments are used to store specific types of data. One segment for instruction codes, one for data elements, etc.

Represented by the .data section and the .bss section. The .data section is holds static data that remains unchanged during the course of the program. The .bss section is also for static data. Data here are declared during the course of the program. The .bss section is zero filled prior to execution.

Represented by the .text section. Fixed data that stores instruction codes.

This contains data passed to functions and procedures during the course of a program.

For comparisons and conditional instructions that control flags.

• OF - Overflow Flag

Indicates overflow of leftmost bit in a signed math operation

• DF - Direction Flag

In string comparison operations, indicates left or right direction of movement. 0 for left-to-right and 1 is right-to-left

• IF - Interrupt Flag

Flags if keyboard or other interrupts are to be ignored or processed. 0 for ignored or 1 for processed.

• TF - Trap Flag

Allows the processor to work in single step mode for debug purposes.

• SF - Sign Flag

Indicates the sign of a arithmetic result.

• ZF - Zero Flag

Indicates whether a result of an arithmetic expression is zero.

• AF - Auxiliary Carry Flag

Used for specialized arithmetic to carry from bit 3 to bit 4.

• PF - Parity Flag

Indicates the total number of 1 (on) bits in the result of an arithmetic expression. If even then 0, odd then 1.

• CF - Carry Flag

Contains the carry from the leftmost bit after an arithmetic operation. It also stores the contents of the last bit of a shift or rotate operation.

These refer to specific areas defined for data, code and stack.

• CS - Code Segment

Contains the starting address of the code segment.

• DS - Data Segment

Contains the starting address of the data segment.

• SS - Stack Segment

Contains the starting address of the stack segment.

There are additional segment registers: ES, FS, GS.

All memory locations within a segment are relative to the starting address of the segment. Since all segments will start at an address that is evenly divisible by 16 (hex 10) there is always a zero in the rightmost hex digit. This zero is not stored in segment registers.

These are used to support floating point operations and Single Instruction Multiple Data (SMID) Instructions, used in graphics and DSP calculations. These are xmm0 to xmm15.

mov <dest>, <src>
; for example

mov ax, 42 ; the integer 42 is put into the 16 bit ax register
mov cl, byte [bvar]  ; into the lower c register, a byte is copied from the address of bvar
mov qword [qvar], rdx ; a quad word from the address of qvar is copied into the 64 bit d register.

• Copies data
• Source and destination cannot both be in memory.
• when copying a double word into a 64 bit register, the upper portion of the register is set to zeros.

The load effective address command lea is used to put the address of a variable into a register.

lea <reg64>, <mem>

; for example
lea rcx, byte [bvar] ; put the location of bvar into the rcx register

Conversion instructions change a variable from one size to another. Narrowing conversions require no specific instructions since the lower portions of registers are directly accessible.

mov rax, 50
mov byte [bval], al

Widening conversions vary depending on the data types involved.

Rotations are essentially shifts that put the bits that would be shifted off the end onto the beginning, or vica verca.

rol <dest>, <imm> ; rotate left
rol <dest> cl


ror <dest>, <imm> ; rotate right
ror <dest> cl
; for example:

rol rcx, 32
ror qword [qNum], cl

the imm or the value in the cl register must be between 1 and 64. The destination operand cannot be immediate.

These include structures such as if statements and looping.

Iteration commands can be used to make simple loops. For example, the following codeblock shows a loop for summing odd integers within a range:

  lpCnt  dq  15
  sum    dq  0

; using the above declerations:
  mov rcx, qword [1pCnt]  ; loop Counter
  mov rax, 1              ; odd integer counter
sumLoop:
  add qword [sum], rax    ; sum current odd interger
  add rax, 2              ; set next odd integer
  dec rcx                 ; decrement loop cionter
  cmp rcx, 0              ; decrement loop counter
  jne sumLoop             

There is a loop instruction which simplifies iteration. It will automatically decriment the rcx register and perform a comparison to 0, jumping when rcx != 0.

; summing n odd numbers

  mov rcx qword [naxN]   ; loop counter
  mov rax, 1             ; pdd int counter
sumLoop:
  add qword [sum], rax   ; sum current odd int.
  add rax, 2             ; next odd int
  loop sumLoop 

The process through which execution is controlled is called the fetch-decode-execute cycle. The instruction is fetched from memory. The processor can access one or more bytes of memory at a given time. The processor stores data in reverse-byte sequence.

For example, for hex number 0725H:

In register: 
|--07--|--25--|
In memory: 
|--25--|--07--|

Signed numbers are often represented in twos complement form. A negative representation of a positive number can be made by flipping the bits and then adding 1. For example: