Assembly language programs are required when one needs to control hardware directly, without any compiler-generated code coming in between the programmer and the microprocessor. This has the advantage of speed of execution as well as predictable latencies. In other words, segments of human-written assembly language code reduces execution time down to the last possible clock cycle. Also, the time for the program control to pass between two checkpoints can be calculated using clock cycle.
The disadvantage of writing programs in Assembly language is tedious and difficult. So for writing larger programs, one prefers to write in high-level languages. C is one such language widely used by programmers who write system software.
Most system software (e.g. the Unix operating system) is written mostly in C, with a few assembly language routines at the core. 95% of the code is in C. The C routines call assembly routines where it must. Sometimes assembly routines call C programs too. One example is where executing assembly language programs up to the point that the execution model required by a C program can be supported does the kernel initializations. From then onwards, the rest of the initialization in C. Therefore, at that point an assembly routine has to call a C routine.
In this project, I will explore the assembly language programming. I will focus on C-callable assembly language programs. I shall use 80X86 (that includes 80386/80486/Pentium/Pentium Pro/MMX/Pentium II microprocessors) based IBM PCs with Linux operating system.
About the Pentium Architecture
1. It is not a load/store architecture.
2. The instruction set is huge! I can only go over a fraction of the instruction set.
3. There are lots of restrictions on how instructions/operands are put together, but there is also an amazing amount of flexibility.
The Intel architectures as a set just do not have enough registers to satisfy most assembly language programmers. Still, the processors have been around for a long time, and they have a sufficient number of registers to do whatever is necessary.
For our general-purpose use, I get
32-bit 16-bit 8-bit 8-bit
(high part of 16) (low part of 16)
EAX AX AH AL
EBX BX BH BL
ECX CX CH CL
EDX DX DH DL
There are a few more, which are not used or discussed in this paper, are only used for memory access ability in the segmented memory model.
Using the registers:
As an operand, just use the name (upper case and lower case both work interchangeably).
EBP is a frame pointer.
ESP is a stack pointer.
One More Register:
Many bits used for controlling the action of the processor and setting state are in the register called EFLAGS. This register contains the condition codes:
OF Overflow flag
SF Sign flag
ZF Zero flag
PF Parity flag
CF Carry flag
The settings of these flags are checked in conditional control instructions. Many instructions set one or more of the flags. There are many other bits in the EFLAGS register.
There are 2 memory models supported in the Pentium architecture. In both models, memory is accessed using an address. It is the way that addresses are formed (within the processor) that differs in the 2 models.
Flat Memory Model
In flat memory model, we can do any type of address arithmetic by treating the address as data. We can use the result of the arithmetic as an address to point at anything within the virtual address space.
Segmented Memory Model
1. Different parts of a program are assumed to be in their own, set-aside portions of memory. These portions are called segments.
2. An address is formed from 2 pieces: a segment location and an offset within a segment.
Note that each of these pieces can be shorter (contain fewer bits) than a whole address. This is the reason that Intel chose this form of memory model for its earliest single-chip processors.
3. There are segments for:
Some would say that the Intel architectures only support 1 addressing mode. It looks (something like) this:
effective address = base reg + (index reg x scaling factor) + displacement
base reg is EAX, EBX, ECX, EDX or ESP or EBP
index reg is EDI or ESI
scaling factor is 1, 2, 4, or 8
The syntax of using this (very general) addressing mode will vary from system to system. It depends on the preprocessor and the syntax accepted by the assembler.
For this implementation, an operand within an instruction that uses this addressing mode could look like
[EAX][EDI*2 + 80]
The effective address calculated will be the contents of register EDI multiplied 2 added to the constant 80, added to the contents of register EAX.
There are extremely few times where a high-level language compiler can utilize such a complex addressing mode. It is much more likely that simplified versions of this mode will be used.
The operand is in a register. The effective address is the register.
mov eax, ecx
Both operands use register mode. The contents of register ecx is copied to register eax.
The operand is in the instruction. The effective address is within the instruction.
mov eax, 26
The second operand uses immediate mode. Within the instruction is the operand. It is copied to register eax.
Register Direct Mode
The effective address is in a register.
mov eax, [esp]
The second operand uses register direct mode. The contents of register esp is the effective address. The contents of memory at the effective address are copied into register eax.
The effective address is in the instruction.
mov eax, var_name
The second operand uses direct mode. The instruction contains the effective address. The contents of memory at the effective address are copied into register eax.
Base Displacement Mode
The effective address is the sum of a constant and the contents of a register.
mov eax, [esp + 4]
The second operand uses base displacement mode. The instruction contains a constant. That constant is added to the contents of register esp to form an effective address. The contents of memory at the effective address are copied into register eax.
The effective address is the sum of the contents of two registers.
mov eax, [esp][esi]
The contents of registers, esp and esi, are added to form an effective address. The contents of memory at the effective address are copied into register eax.
PC Relative Mode
The effective address is the sum of the contents of the PC and a constant contained within the instruction.
The content of the program counter is added to an offset that is within the machine code for the instruction. The resulting sum is placed back into the program counter. Note that from the assembly language it is not clear that a PC relative addressing mode is used. It is the assembler that generates the offset to place in the instruction.
1. Many of the instructions have exactly 2 operands. If there are 2 operands, then one of them will be required to use register mode, and the other will have no restrictions on its addressing mode.
2. There are most often ways of specifying the same instruction for 8-, 16-, or 32-bit operands
Meanings of the operand specifications:
reg - register mode operand, 32-bit register
reg8 - register mode operand, 8-bit register
r/m - general addressing mode, 32-bit
r/m8 - general addressing mode, 8-bit
immed - 32-bit immediate is in the instruction
immed8 - 8-bit immediate is in the instruction
m - symbol (label) in the instruction is the effective address
mov reg, r/m ; copy data
movsx reg, r/m8 ; sign extend and copy data
movzx reg, r/m8 ; zero extend and copy data
lea reg, m ; get effective address
mov EAX, 23 ; places 32-bit 2's complement immediate 23 into
movsx ECX, AL ; sign extends the 8-bit quantity in register AL to 32
; bits, and places it in ECX
mov [esp], -1 ; places value -1 into memory, address given by
; contents of esp
lea EBX, loop_top ; put the address assigned (by the assembler) to label
; loop_top into register EBX
add reg, r/m ; two's complement addition
inc reg ; add 1 to operand
sub reg, r/m ; two's complement subtraction
dec reg ; subtract 1 from operand
neg r/m ; get additive inverse of operand
mul eax, r/m ; unsigned multiplication edx||eax <- eax * r/m
imul r/m ; 2's comp. Multiplication edx||eax <- eax * r/m
reg, r/m ; reg <- reg * r/m
reg, immed ; reg <- reg * immed
div r/m ; unsigned division does edx||eax / r/m, eax <- quotient
; edx <- remainder
idiv r/m ; 2's complement division does edx||eax / r/m
; eax <- quotient, edx <- remainder
cmp reg, r/m ; sets EFLAGS based on
r/m, immed ; second operand - first operand
r/m, immed8 ; sign extends immed8 before subtract
neg [eax + 4] ; takes doubleword at address eax+4 and finds its
; additive inverse, then places the additive inverse
; back at that address the instruction should probably
neg dword ptr [eax + 4]
inc ecx ; adds one to contents of register ecx, and
; result goes back to ecx
not r/m ; logical not
and reg, r/m ; logical and
or reg, r/m ; logical or
xor reg, r/m ; logical exclusive or
test r/m, reg ; logical and to set EFLAGS
and edx, 00330000h ; logical and of contents of register edx (bitwise)
; with 0x00330000, result goes back to edx
Floating Point Arithmetic
Since the newer architectures have room for floating point hardware on chip, Intel defined a simple-to-implement extension to the architecture to do floating-point arithmetic. In their usual zeal, they have included MANY instructions to do floating-point operations.
The mechanism is simple. A set of 8 registers are organized and maintained (by hardware) as a stack of floating point values. ST refers to the stack top. ST(1) refers to the register within the stack that is next to ST. ST and ST(0) are synonyms.
There are separate instructions to test and compare the values of floating point variables.
finit ; initialize the FPU
fld m32 ; load floating point value
fldz ; load floating point value 0.0
fst m32 ; store floating point value
fstp m32 ; store floating point value
m64 ; and pop ST
fadd m32 ; floating point addition
faddp ST(i), ST ; floating point addition and pop ST
The only instructions that actually allow the reading and writing of I/O devices are privileged. The OS must handle these things. But, in writing programs that do something useful, we need input and output. Therefore, there are some simple macros defined to help us do I/O.
These are used just like instructions.
put_ch r/m ; print character in the least significant byte of 32-bit
get_ch r/m ; character will be in AL
put_str m ; print null terminated string given by label m
These are the same control instructions that all started with the character 'b' in SASM.
jmp m ; unconditional jump
jg m ; jump if greater than 0
jge m ; jump if greater than or equal to 0
jl m ; jump if less than 0
jle m ; jump if less than or equal to 0
This project provides the basic knowledge of Pentium Assembly Language. Pentium instruction sets are very large, therefore, further investigation is needed to understand the language.