Course Review and Cheat Sheet

Writing Numbers in Binary, Decimal, Hexadecimal

Bitwise Operations

Sizes of Stuff

int value=1; /* value to test, starts at first (lowest) bit */
int bit=0;
while (value!=0) {
	value=value+value; /* moves over by one bit (value=value<<1 would work too) */
	bit++;
}
return bit;

(Try this in NetRun now!)

Signed versus Unsigned Integers

two's complement signed integers.  The sign bit.  To flip the sign, flip all the bits and then add one.

Concept of Machine Code

Or, why this code works, and returns 73:

const char commands[]={
	0xb0,73, /* load a value to return */
	0xc3 /* return from the current function */
};
int foo(void) {
	typedef int (*fnptr)(void); // pointer to a function returning an int
	fnptr f=(fnptr)commands; // typecast the command array to a function
	return f(); // call the new function!
}

(Try this in NetRun now!)

The Registers

Here's the full list of x86 registers.  The new 64 bit registers are shown in red.

Conditional Jumps

Every C flow-control construct can be written using just "if" and "goto", which usually map one-to-one to a compare-and-jump sequence in assembly.

Call, Return, and The Stack

• push == subtract the stack pointer, and move QWORD there.
• pop == move QWORD off stack, and add stack pointer.  Must match with a push!
• call == push address to come back to, and jmp to new function.
• ret == pop address to return to, and jmp back there.

Accessing Memory in Arrays

Accessing Memory in a Class or Struct

Memory Allocation: Static, Malloc, and the Stack

mov DWORD[myInt],7 ; overwrite our int
mov eax,DWORD[myInt] ; copy the modified int into eax
ret

section .data
myInt:
	dd 2 ; "data DWORD" containing this value

(Try this in NetRun now!)

Dynamic allocation with malloc (call "free" to deallocate the space when you're done):

mov rdi, 4; malloc's first (and only) parameter: number of bytes to allocate
extern malloc
call malloc
; on return, rax points to our newly-allocated memory

mov DWORD [rax],7; write constant into memory
mov eax,DWORD [rax]; read it back from memory
ret

(Try this in NetRun now!)

Dynamic allocation on the stack (be sure to hand the space back afterwards!):

sub rsp,8 ; I claim the next eight bytes in the name of... me!

mov DWORD [rsp],1492 ; store an integer into our stack space
mov eax,DWORD [rsp] ; read integer from where we stored it

add rsp,8 ; Hand back the stack space
ret 

(Try this in NetRun now!)

The stack must always be 8 byte aligned, which is why I'm grabbing 8 bytes, although I only need 4 bytes.  Actually, if you call any functions that do floating point work, the stack actually needs to be 16 byte alignedonce you're inside the function!

Defining Functions in Assembly, mixing C++ and Assembly

To make an assembly function visible from outside, from your assembly say:

    global myfunc
    myfunc:

You may need to add underscores, or capital letters, or some other crud depending on the system.

To call this from C++, declare a function prototype:

   extern "C" int myfunc(int someParameter);

Your function will find its parameters in registers (64-bit mode) or on the stack (32-bit mode).  The exact registers depend on the machine's calling convention:

You can also intermix assembly language inside your C++ code using "inline assembly".  The syntax is nice on Windows: __asm { mov eax,13 }, but hideous and dyslexic on Linux or Mac.