Basic use of immediates vs. square brackets in YASM/NASM x86 assembly

Indeed, your thought is correct.That is, bl will contain 5 and cl the memory address of buffer(in fact the label buffer is a memory address itself).

---

Now, let me explain the differences between the operations you mentioned:

• moving an immediate into a register can be done using mov reg,imm.What may be confusing is that labels e.g buffer are immediate values themselves that contain an address.

• You cannot really move a register into an immediate, since immediate values are constants, like 2 or FF1Ah.What you can do is move a register to the place where the constant points to.You can do it like mov [const], reg .

• You can also use indirect addressing like mov reg2,[reg1] provided reg1 points to a valid location, and it will transfer the value pointed by reg1 to reg2.

---

So, mov cl, buffer will move the address of buffer to cl(which may or may not give the correct address, since cl is only one byte long) , whereas mov cl, [buffer] will get the actual value.

Summary

• When you use [a], then you refer to the value at the place where a points to.For example, if a is F5B1, then [a] refers to the address F5B1 in RAM.
• Labels are addresses,i.e values like F5B1.
• Values stored in registers do not have to be referenced to as [reg] because registers do not have addresses.In fact, registers can be thought of as immediate values.

The square brackets essentially work like a dereference operator (e.g., like * in C).

So, something like

mov REG, x

moves the value of x into REG, whereas

mov REG, [x]

moves the value of the memory location where x points to into REG. Note that if x is a label, its value is the address of that label.

As for you're question:

Am I correct in understanding that bl will contain the value 5, and cl will contain the memory address of the variable buffer?

Yes, you are correct. But beware that, since CL is only 8 bits wide, it will only contain the least significant byte of the address of buffer.

You are getting the idea. However, there are a few details worth bearing in mind:

1. Addresses can and usually are greater than what 8 bits can hold (cl is 8-bit, cx is 16-bit, ecx is 32-bit, rcx is 64-bit). So, cl is likely going to be unequal to the address of the variable buffer. It'll only have the least significant 8 bits of the address.
2. If there are interrupt routines or threads that can preempt the above code and/or access buffer, the value in bl may differ from 5. Broken interrupt routines may actually affect any register when they fail to preserve register values.