Penguin
Note: You are viewing an old revision of this page. View the current version.

AssemblyLanguage is 1:1 translation of MachineCode into English mnemonics.

The Art of AssemblyLanguage Programming is a delicate topic. By programming in AssemblyLanguage you can hand optimize code and achieve efficiency that is difficult if not impossible to duplicate in a higher level language. However, current computers are fast enough to write most code in less efficient higher level languages. AssemblyLanguage is still used for embedded systems (where space and CPU speed are limited), and in parts of an OperatingSystem that are run very frequently or must run fast (InteruptHandler?s etc.). Some parts of the GNU C library are also written in assembly for the same reasons (for example, some of the maths functions).

AssemblyLanguage code is not portable across different CPU architectures, of which there are many: Intel x86, MIPS, and the Motorola m68000 series, to name but a few. Early versions of Unix were written in assembler, and when BellLabs got new machines, they re-wrote their operating system for the new MachineCode, until they finally re-wrote most of it in C in 1973.

AssemblyLanguage code is difficult to understand and maintain. It is usually easier to start from scratch than to debug faulty code.

A Compiler such as gcc(1) will hide its generation of AssemblyLanguage code from you as it generates its object files and the executables. It is however possible to tell it to generate the AssemblyLanguage code for you by passing it the -S CommandLine option

Here is an example. First, the C code

int main(void) {

int i;

i = 5; i = i * 3; printf("%d\n",i); i = 0xff; return i;

}

Now you can translate this to assembler. If I do this on an x86 (ie Intel machine), I get

$ gcc -S x.c ; cat x.s

.file "x.c" .version "01.01"

gcc2_compiled.: .section .rodata

.LC0

.string "%d\n"

.text

.align 4

.globl main

.type main,@function

main

pushl %ebp movl %esp,%ebp subl $24,%esp movl $5,-4(%ebp) movl -4(%ebp),%eax movl %eax,%edx addl %edx,%edx leal (%eax,%edx),%ecx movl %ecx,-4(%ebp) addl $-8,%esp movl -4(%ebp),%eax pushl %eax pushl $.LC0 call printf addl $16,%esp movl $255,-4(%ebp) movl -4(%ebp),%edx movl %edx,%eax jmp .L2 .p2align 4,,7

.L2

leave ret

.Lfe1

.size main,.Lfe1-main .ident "GCC: (GNU) 2.95.3 20010315 (release)"

movl, jmp, addl, etc are mnemonics for individual CPU instruction OpCodes. %esp, _%ebp etc are mnemonics for registers. For example, %esp is the Stack Pointer - it points to the top of the current process's Stack. The first movl copies the value in %esp into %ebp, then the subl subtracts 24 off %esp, so that the Stack has grown by 24 bytes. The next movl copies the value 5 into Stack, 4 bytes below its end. This address is where the variable i is being stored, so all accesses to i in the C code become references to this memory location in MachineCode. We can also witness an optimization here: instead of doing i*3, it does i+(i+i). That's the addl and leal instructions. Below that, it puts some pointers (to printf's arguments) on the stack and calls printf, which pulls its arguments from the stack.

As you can see, explaining what AssemblyLanguage code is doing line-by-line is tediously boring. This is how programmers used to write code, and it is a common fact that AssemblyLanguage programmers get paid more per line of code than those who hack away in higher level languages.

We can also note that it is extremely bad for your health to rely on the gcc(1) output of some C code when learning x86 AssemblyLanguage. gcc(1) generates extremely horrid code on occassion, especially when working with multiplication and division because x86 multiplication and division instructions are restricted in the registers they can use.

As stated learning AssemblyLanguage by inspecting the output of gcc is hardly sensible. Inspecting the generated instructions when optimising C code is quite usefull. Especialy when mixing different sizes of integers (char, int long) the code can be flooded with unexpected typecasting instructions which are not so visible in the C code. These instructions are quite obvious in the AssemblyLanguage (lots of and instructions and often additional mov).

Another sample piece of AssemblyLanguage code for Linux can be found in the HelloWorld page.


CategoryProgrammingLanguages