Assembly

5תרגול תכנות באסמבלי

Assembly vs. Higher level languages There are NO variables’ type definitions.

All kinds of data are stored in the same registers. We need to know what we are working it in order to use

the right instructions. Memory = a large, byte-addressable array.

Only a limited set of registers is used to store data while running the program. If we need more room we must save the data into

memory and later reread it.

No special structures (instructions) for “if” / “switch” / “loops” (for, while, do-while), or even functions!

How to - Disassembly of code Compilation of code:

gcc -c code.c We get the file: code.o

Disassembly: objdump -d code.o We get an assembly-like code that represents the c

code appeared in file code.c Or:

gcc -S code.c We get a code.s file that contains an assembly code

created by the compiler.

Standard data typesAssembly

In Assembly: size = type of variable.

Words, double words …. Due to its origins as a 16-bit architecture that

expanded into a 32-bit one, Intel uses the term “word” to refer to a 16-bit data type.

32-bit quantities as “double words”. 64-bit quantities as “quad words”. Most instructions we will encounter operate on

bytes or double words. Each instruction has 3 variants, depending on its

suffix (‘b’ – byte / ‘w’ – word / ‘l’ – double word).

The Registers An IA32 CPU contains a set of eight registers storing

32-bit values. These registers are used to store integer data as well as pointers.

The registers names all begin with %e (extend), but otherwise they have peculiar names.

In the original 8086 CPU each register had a specific target (and hence it got its name). Today most of these targets are less significant. Some instructions use fixed registers as sources and/or

destinations. Within procedures there are different conventions for

saving and restoring the first three registers (%eax, %ecx, and %edx), than for the next three (%ebx, %edi, and %esi).

%ebp and %esp contain pointers to important places in the program stack.

The File Register

%bx

Partial access to a register

The low-order two bytes of the first four registers can be independently read or written by the byte operation instructions. This feature was provided to allow backward compatibility.

When a byte instruction updates one of these single-byte “register elements,” the remaining three bytes of the register do not change.

Same goes for the low-order 16 bits of each register, using word operation instructions.

Operand Forms

Move to / from memory Instructions

Important Suffixes

‘l’ - double word. ‘w’ - word. ‘b’ - byte ‘s’ - single (for floating point) ‘t’ - special extension (– we won’t get into

that!)

movl Operand Combinations

Cannot do memory-memory transfers with single instruction

movl

Imm

Reg

Mem

Reg

Mem

Reg

Mem

Reg

Source Destination

movl $0x4,%eax

movl $-147,(%eax)

movl %eax,%edx

movl %eax,(%edx)

movl (%eax),%edx

C Analog

temp = 0x4;

*p = -147;

temp2 = temp1;

*p = temp;

temp = *p;

movb & movw The movb instruction is similar, but it moves just

a single byte. When one of the operands is a register, it must be one of the eight single-byte register elements.

Similarly, the movw instruction moves two bytes. When one of its operands is a register, it must be one of the eight two-byte register elements.

Both the movsbl and the movzbl instruction serve to copy a byte and to set the remaining bits in the destination: movsbl - signed extension. movzbl - zero extension.

Another example

(Assume initially that %dh = 8D, %eax = 98765432)

movb %dh,%al %eax = 9876548D movsbl %dh,%eax %eax = FFFFFF8D movzbl %dh,%eax %eax = 0000008D

C vs. Assembly example

Arithmetic & Logical Operations

Arithmetic & Logical Operations (2)

With the exception of leal, each of these instructions has a counterpart that operates on words (16 bits) and on bytes (by replacing the suffix).

Again, cannot do memory-memory transfers with single instruction

“Load Effective Address” (leal)

The “Load Effective Address” (leal) instruction is actually a variant of the movl instruction.

Its first operand appears to be a memory reference, but instead of reading from the designated location, the instruction copies the effective address to the destination.

This instruction can be used to generate pointers for later memory references.

The leal Instruction can be used to compactly describe common arithmetic operations.

If register %edx contains value x, then the instruction:leal 7(%edx,%edx,4), %eax

will set register %eax to 5x + 7. It is commonly used to perform simple arithmetic:

(%eax = x; %ecx = y) leal 6(%eax), %edx leal (%eax,%ecx), %edx leal (%eax,%ecx,4), %edx leal 7(%eax,%eax,8), %edx leal 0xA(,%ecx,4), %edx leal 9(%eax,%ecx,2), %edx

leal (2)

= x+6

= x+y

= x+4y

= 9x+7

= 4y+10

=x+2y+9

Either logical or arithmetic

k is a number between 0 and 31, or the single-byte register %cl

Suppose that x and n are stored at memory locations with offsets 8 and 12, respectively, relative to the address in register %ebp

get n get x x <<= 2 x >>= n

Shift

movl 12(%ebp), %ecx

movl 8(%ebp), %eax

sall $2,%eax

sarl %cl,%eax

C vs. Assembly example

mul & div Instructions

Code example

(x at %ebp+8, y at %ebp+12) movl 8(%ebp),%eax Put x in %eax imull 12(%ebp) Multiply by y pushl %edx Push high-order 32 bits pushl %eax Push low-order 32 bits

Yet, another example

(x at %ebp+8, y at %ebp+12) movl 8(%ebp),%eax Put x in %eax cltd Sign extend into

%edx idivl 12(%ebp) Divide by y pushl %eax Push x / y pushl %edx Push x % y