Comments on: x86 Assembly for C Programmers 1

By: Robert Bieber

Robert Bieber — Fri, 06 Jan 2012 22:34:47 +0000

Just a heads up, you define “Word” at the top as 32 bits, but then go on to explain that a DWORD is also 32 bits. The reason for this is that while a “word” generally speaking fits the definition you gave, in x86 assembly in particular it’s usually used to refer to 2 bytes, even though we’ve moved on to 32 and 64 bit processors. This is why a DWORD (double word) is the same size as the processor’s actual word size.

By: endeavormac

endeavormac — Tue, 13 Apr 2010 17:14:14 +0000

BX is simply the 16 least significant bits of the EBX register. Actually, I’m not entirely sure if it’s the least or most significant bits. In any case, you can use BX to access the 16 (most|least) significant bits of the EBX register (assuming a current 32bit intel CPU).

This url may provide some enlightenment: http://www.arl.wustl.edu/~lockwood/class/cs306/books/artofasm/Chapter_4/CH04-1.html#HEADING1-42

A short is 16 bits, so make sure your printf string is adjusted (You’ll need %h) http://www.opengroup.org/onlinepubs/000095399/functions/printf.html

So if you want to print out BX, you’ll need to push BX onto the stack, followed by a pointer to a string “%h”, and then call printf. Because BX is only 16 bits and, assuming a 32 bit platform, you’re pushing BX onto a 32 bit word, you may want to mov a 0×0 into that stack space first, or otherwise insure that it is empty, to account for whatever may already be in place of the other 16 bits. I’m not positive that would be necessary, you would have to experiment.

You may have better luck creating a simple C app that does all this and then “gcc source.c -S” to see what you get.

By: Min

Min — Tue, 06 Apr 2010 07:32:37 +0000

is there a way to make the output 16 bit instead of 32 bit? For example i want bx instead of ebx

By: inter

inter — Thu, 29 Oct 2009 22:49:53 +0000

gcc -O0 -g -c one.c
objdump -C -M intel -S one.o

This gives an even better result (asm code with source code side by side).

By: endeavormac

endeavormac — Fri, 23 Oct 2009 21:13:23 +0000

I didn’t know about this feature for gcc, and this is awesome. Thanks!

By: jldugger

jldugger — Fri, 23 Oct 2009 20:54:33 +0000

gcc -S -masm=intel -o one.asm one.c

For writing your own code, use the compiler instead of the object analyzer. You get jump targets, which is damn handy.

Also stack alignment has more to do with processor design than memory segmentation.

By: drill

drill — Fri, 23 Oct 2009 19:27:48 +0000

Two requests:

1) Give this series its own special tag on your blog so it’s easy to access the whole thing when you’re done ;)

2) some ideas of simple projects a beginner could do that are actually doable
a) in assembly
b) by someone with the knowledge level this is aimed at.

I’m bookmarking your site.

By: endeavormac

endeavormac — Fri, 23 Oct 2009 16:36:18 +0000

You are correct, thanks. Correction has been made.

By: J

Fri, 23 Oct 2009 16:11:19 +0000

Great tutorial :) I feel like I could just about jump in and start writing.

In the synopsis for the instruction at 80483df, perhaps the line:
0xdf = 0×02…
should read:
0xdf + 0×02
?
I stared at that for a couple of minutes before working it out.