Pentium Assembler Using gcc

This page is a potpourri. It attempts to describe portions of the process of writing Pentium assembly code using gcc. This explanation is done in the context of our current class, specifically using our textbook. Through examples and brief explanations, I attempt to guide you through the potholes of writing Pentium assembly language using gcc.

1. Hello world example

Let's look at an example, good old "Hello world" with each line commented:

2. The basics

The syntactic style supported by gcc is generally known as the "AT&T style." It was developed in conjunction with Unix and pre-dates the Intel style used in our textbook and by Microsoft in its assembly language called Microsoft Assembly (MASM).

Comments start with a pound sign (#). C++ style comments (// and /* ... */) are also supported, but not after every statement type (like some of the pseudo-instructions). I would just stick with #.

As in C/C++, the first function is called main. The underscore (_main) is added to avoid name conflicts.

2.1. Instruction format

Assembly programs contain assembly instructions and assembler directives called pseudo-instructions. Pseudo-instructions generally start with a dot (.) and have many functions. They do not translate directly into Pentium assembler instructions, rather they guide the assembler in constructing correct machine code for your assembly code.

Assembly instructions have the format:

Each of these fields is optional (blank lines are OK). Anything on a line after the pound sign (#) is ignored. Here are some examples:

2.2. Program segments

Programs have the following segments in memory with syntax in parens:

1. Text - the main section containing your code and constant values ( .text )
2. Data - contains initialized global variables ( .data )
3. Bss - contains un-initialized global variables ( .bss )

2.3. The stack

A section of memory is reserved for your use as a stack. The stack has two primary uses:

• Storing and passing the values of function parameters
• Storing the value of the local variables of a function

Each of these cases is described below, but the stack functions 

• The address of the top of the stack is maintained in register %esp.
• The stack starts at a high memory address. As items are added to the stack, it grows downward. Because of this %esp decreases as the number of items on the stack grows and increases as the stack shrinks.
• The pushl src instruction places the value in src on the stack and then decrements the stack pointer (%esp) by 4 bytes.
• The popl dest instruction copies the top value on the stack to dest and then increments the stack pointer (%esp) by 4 bytes.
• The stack pointer (%esp) can be moved an arbitrary number of bytes using the addl instruction.

Examples using the stack follow in the "Calling functions" and "Local variables" sections.

3. Arithmetic

Coming soon...

4. Calling functions

Calling a function is a three step process:

1. Place parameters to the function on the stack
2. Call the function using the call instruction
3. Adjust the stack pointer (%esp) to effectively remove the parameters from the stack

Here's an example of a call to a simple function called plus10():

Please note the first line of plus10. The first 4-byte argument resides 8 bytes from the top of the stack. This is because the call instruction pushes the return address of the calling function on the stack before ceding control of the program to plus10.

The return value of a function is usually placed in the %eax register.

For functions with multiple arguments, each argument is placed on the stack in last-to-first order.  For example, a call to foo( 7, 14) would look like this:

5. Local variables

Local variables for a function (including main) are allocated on the stack. There are 3 things to know here:

• Adjust the stack pointer (held in %esp) to create space on the stack for the local variable
• Use that space
• Return the stack pointer, eliminating the local variable space

6. Global variables

Global variables are (usually) placed in the data section. The name of the global variable is specified using a label. The size of the variable is indicated by the pseudo-opcode specified:

• .long - an 4 byte integer
• .word - a 2 byte integer
• .byte -  a 1 byte quantity, char or integer
• .space - allocates a number of bytes, such as storage for an array

Here are some examples:

These are also global variables with an initial value. Un-initialized global variables should be defined in the "bss" section.

7. Input/output

We will output data to the screen using a C function called printf(). You can query Visual-C++ for a manual page on this function. Here's an example usage:

We will read values from the keyboard using C function scanf(). It's format is similar to printf(). Here's an example:

8. C "calling conventions"

"The C library is nothing if not consistent, and that is its greatest virtue"

- Jeff Duntemann, "Assembly Language Step-by-step"

C library functions must be called using the following conventions:

• Preserve registers - When you call a function, it may change register values. Therefore, if you wish to preserve the values in registers (like ebx, esp, ebp, esi, and edi), then you must push them onto the stack prior to the call and restore them after the call.
• Return value - The return value of a function call is placed in register eax. If the return value is greater than 32 bits, up to 64 bits, then the lower 32 bits are in eax and the high 32 bits are in edx.
• Parameter order - Parameters to a function are pushed onto the stack in reverse order. For example, a call to f( x, y, z) is done by first pushing z, then push y, and finally push x. Then you issue the call opcode.
• After the call - Functions do not remove their parameters from the stack, so it is the caller's duty to clean-up upon a function return. As we have seen, the stack pointer (esp register) is fixed by adding the number of bytes to erase to its current value.

I recommend that you use these conventions with your own functions as well.

9. Differences: gcc and our text

There are some very fundamental differences between the assembly code format used in gcc and that used in our textbook.

• gcc is case-sensitive. In general, use lower-case (thankfully) rather than the upper case in the text.
• The order of arguments in dyadic instructions (those with two operands) is switched. In our text the order of operands to, for example, add is add dest, src. The order in gcc is add src, dest.
• In gcc, many instructions have a suffix defining the size of the operands. For example, rather than a single add instruction, gcc supports addl, addw, and addb for long (4 bytes), word (2 bytes) and byte (1 byte) quantities.
• Immediate values (constants) are prefixed with a $.
• Registers are prefixed with a %.
• Memory is referenced using parens.
• The format of pseudo-instructions controlling assembly are different. For example gcc uses .globl rather than PUBLIC to designate a public symbol.

Here are some examples for these differences:

10. Instructions

Selected (and hopefully most important) instructions on a separate page:

instructions.htm

11. Examples

Also, on a separate page, some tasty assembly code examples:

examples.htm