Question

There is something I can’t digest. I’m learning some assembler and right now I’m at the chapter with addressing. I understand the concept of brackets for dereferencing, but somehow when I see the usage of it I just can’t soak up the point of it. To be a little bit more exact here is where my confusion started:

mov al, [L1]

Here I suppose L1 as an example case is some kind of macro which is later substituted for a real address in the machine code, right?

So what this instruction does is: dereferencing al register (because you could hardly change physical address) and changing the value to the one stored at L1.

If till now everything is ok:

mov [L1], al

that would analogicaly mean, there must have been an address stored (so there was some point in doing this) and you change it to some other place in memory, right?

If you could just tell me it’s ok in case you don’t see any mistakes please do it, that would make it possible for me to continue learning.

One last thing, NASM adds a bunch of 0xAA55 under my code (this sequence is supposed to end the program right?), why is it there so many times?

Answer 1

L1 is typically/probably a label, associated with one particular address in memory. The programmer defines various labels for his/her convenience, and such labels are used to symbolically represent a particular location in memory (L1 is a lousy name; labels are typically indicative of the underlying purpose of the location: say, PingCounter, ErrorMessage, Login and the like).

A label for 1 byte of static storage is how a C compiler would implement char L1; at global scope.

---

In NASM syntax, mov edi, L1 will assemble to the mov eax, imm32 form of mov, i.e. the label address will become a 32-bit immediate in the machine code. (The assembler doesn’t know the final numeric value, but the linker does.) Beware that in MASM syntax, this would be a load and you’d need mov edi, OFFSET L1 to get a label address as an immediate.

But mov al, [L1] will assemble to a different instruction, with the 32-bit address embedded in the machine code as an address to be dereferenced. This instruction loads 1 byte from the address L1, and places it in AL.

In the assembly language, this indirect addressing mode is signified by square bracketing the source or destination operand of a given instruction. (But not both: x86 only supports at most one explicit memory operand per instruction.)

mov al, [L1]

uses the address stored in L1, to locate some location in memory and reads 1 byte (= 8 bits = the size of AL register) at this location, and loads it into the AL register.

  mov [L1], al

Does this in reverse. i.e., specifically, read the address stored in L1, use this address to find a particular place in memory and stores the contents of AL register there.

---

Provided that you understand the following information to be incomplete and somewhat outdated with regards to the newer processors in the x86 family, this primer on the 8086 architecture is probably very useful to get one started with Assembly language for the x86 family.
The advantage of starting with this “antiquity of a CPU” (still in use, actually), is that the fundamental concepts are all there, unencumbered of the newer sets of registers, fancy addressing modes, modes of operation and other concepts. The bigger sizes, features and modes of the newer CPUs merely introduce a combinatorial explosion of options, all (most?) of them useful in their way, but essentially irrelevant for an initiation.