If you also don't modify any of the callee saved registers specified by the ABI, yes.

Usually, but if you prefer you can access them as offsets from esp instead.

If you follow the convention, ebp will point to the same spot in the stack frame through the entire body of the function.

esp typically changes during the execution of the function, so the offset from esp needed to access a parameter or local variable will be different at some place within the body of the function from some other place in the body of the same function. That can quckly lead to coding errors.

But if you find yourself short of general purpose registers (pretty common in 32 bit x86) you may find it worth the trouble to use ebp to hold some other pointer, while you access parameters and local variables using esp.

I created this program, it's return value should be 2 to the 3rd power:

But the assembler gives these warnings:

What do you think is wrong?

I dont use GNU as (I use nasm and tasm) but WTH are these:
Oh and those assembler messages are errors and not warnings.
----edit----
Shouldn't it be more like:
(Kind of a mish-mash between intel and at&t syntax)

AFAIK that means get the number at the memory address stored in %ebp offset by 8 bytes.

I know.

What are 2 and 3?

1) Not every operand type (constant, memory reference, register) is valid for every operand of every instruction.

Most instructions support just a few combinations of operands and many operands can only be registers, in some cases only specific registers.

You should be working with a reference manual for the instruction set, so you have that info available.

2) You also have a logic error (which the assembler can't know is an error, so it won't be reported):
That subl allocates a local 32 bit value at -4(%ebp) but it doesn't initialize that value to anything. Then you seem to be trying to use the value as if it had been initialized.

Once you understand what operations are best or only doable in registers, I expect you would eliminate the use of -4(%ebp) from your code and use a register instead.

But in later projects, you may need to use memory for local variables.

Whether you use memory or registers for local variables, you should remember to initialize your local variables, just as you know you need to in C.

I fixed the logic error.

Anyway, if you can't use some addressing modes for some operations, then how are you supposed to write good programs? In fact, my code is very similar to the power example in the book, and as shows errors on some parts that are the same!

You need to understand that assembler's purpose is not convinient programing. That is what high level languages are for.
Assembler is used to program as close as possible to the CPU's abilities.

I know that. I'm still just saying...

And where do I get this reference and how do I work around these limitations?

Every CPU manufacturer issues quite detailed documentation describing all the peculiarities.

You haven't yet looked, into, say, ARM . ARM is actually not bad - much more RISCy, so easier to understand. OTOH, it can be both big and little endian, and IIRC it has so called thumb mode (16 bits instead of 32 bits).

Maybe that's a good idea. Is there some sort of ARM emulator available? Perhaps even something that can run Linux?

I just found an article that describes how to set up QEMU to emulate an ARM machine and install Linux on it! Gotta try it!

0 members found this post helpful.

ARM can be run under QEMU and there ready-made bootable Linux images - Debian. Use your favorite WEB search engine, something like

QEMU ARM Debian image

should suffice.

I did run ARM emulator myself - 'gcc' works in it. I.e. you can compile natively inside QEMU.

Have a look at page 263 of the book. There is a reference table of some common x86 instructions. Depending on what chip you intend to prgram you might have to contact the chip manufacturer.

As for the work around:
Again, this are physical limitations we are talking about. High level languages 'hide' the chip's specific architecture.
If you are still wondering, why you can't do something like

then keep in mind, that -4(%ebp) and 8(%ebp) point to just some memory locations. So it is just some circuits that are capable of holding some values. There is no cicuitry in your memory that can multiply this two dates. Only your CPU provides that functionality. So before you can operate on those values, your CPU has to fetch them first to its registers which have that special circuits to do a mutliplication and other logical operations.

I looked on AMD's web site for a good directory of the documents you should get. I've seen that directory before, but couldn't find it.

I can still find all the individual documents. These are documentation for x86_64 CPUs. They cover both the 32 bit and 64 bit instruction sets, because the CPUs themselves include both. But some of the explanation is pretty skimpy for 32 bit specific sub topics, because that is not what they want you to use. You might need to find older documentation for more detail on 32 bit. (But I still think you should switch to 64 bit asm).

The pdf with the basic instruction set documentation is
http://support.amd.com/us/Processor_TechDocs/24594.pdf

Some others you should get include 24592, 26568 and the two documents at
http://www.x86-64.org/documentation.html

I figured out that part of your problem.

You already understood that the book was giving examples in 32 bit x86 asm and you know you have 64 bit Linux installed so the as command will default to 64 bit x86 asm. But you seem to have ignored that problem.

If you use as --32 instead of as it will assemble a program in 32 bit x86 asm.

The two asm languages have so much superficial similarity, that you got a trivial program written for 32 bit x86 asm to assemble and even run correctly in 64 bit x86 asm (even though each instruction did something subtly different). But you can't extend that to bigger projects. For example, 32 bit x86 asm has the pushl instruction to push a 32 bit value onto the stack. In 64 bit x86 asm, there is a lot more attention to stack alignment, so they intentionally prevented you from pushing 32 bits onto the stack. Regardless of the source size of the thing you want to push, it must be pushed onto the stack as 64 bits.

In memory references other than push/pop, the default integer size in x86_64 is still 32 bits, so there is no problem reading and writing 32 bit integers from/to memory, including from/to memory allocated on the stack and accessed through (%rsp) or (%rbp). You just can't push nor pop 32 bits.

So if you want to continue typing in 32 bit x86 asm examples, start assembling and linking them in 32 bit mode. (No special option is needed to run 32 bit in 64 bit Linux, just to assemble and link 32 bit).

I think you would learn more if you translated the examples to 64 bit x86 asm and assembled and linked the default way.

Does 64 bit ASM work on a 32bit OS working on a 64 bit processor?