Question

In assembly language if we use

mov eax, dword ptr[ebx] 

then it means copy the value pointed by ebx (ebx contains the address value, not the actual value, this instruction copies the actual value in the address)?

If we use

mov eax, dword ptr[some_variable] 

then it means copy the value of variable ‘some_variable’ itself to eax, not copy the value pointed by variable ‘some_variable’?

Is my understanding correct?

If yes, I’m confused why the same assembly instruction has two different meansings – in the first case there is a level of indirection, but in the second there is no additional level of indirection.

Any comment?

EDIT:

Not every [] does not taking any effect, for example, instruction xchg will take a level of in-direction, which loads value pointed by edx.

Whole source code could be found from,

http://www.codeproject.com/KB/threads/spinlocks.aspx

#ifdef WIN32 inline int CPP_SpinLock::TestAndSet(int* targetAddress, int nValue) {     __asm {         mov edx, dword ptr [pTargetAddress]         mov eax, nValue         lock xchg eax, dword ptr [edx]     } } #endif // WIN32 

Answer 1

In both cases you ask the processor to move the value from a specified address. It’s one level of indirection. In the first case you ask it to take the address from a specified register. In the second case you specify an offset directly.

x86 processors don’t support dual level indirection, so it’s not possible to request to load a value from an address specified somewhere in memory – you have to load the address onto a register.

Under a number of assemblers (MASM and built into VC++ assembler for example) you could as well write just

mov eax, dword ptr some_variable 

without brackets, it would mean the same.

You could write

mov eax, dword ptr [variable][ebx] 

this would instruct to take the address of ‘variable’, then add value of ebx and use the sum as an address from which to load a value. This is often used for accessing array elements by index. (Variations on the syntax are supported, like mov eax, dword ptr variable[ebx] being commonly used and mov eax, dword ptr [variable + ebx] also being common.)

In all these cases the processor would do the same – load a value from a specified address. It’s one level of indirection each time.