MOV and expression source

[frktons]

What possibility offers MASM to have simple or complex source expression operands
in MOV instruction?

Can I do:

Code Select Expand


mov eax, 13 * 127 + 12


or something more complex, or the source operand can never be an expession ?

I've seen we can do:

Code Select Expand


mov eax, [ebx + 16]


and I wonder if it can be done for operands different than registers, and to what
extent. And the syntax that we should use in case it is possible?

Thanks

Frank

[zemtex]

You can use a various combination of constants, the assembler will calculate it for you and put it into the executable. But you cant use registers, that requires the use of special instructions like MUL or DIV.

An optimization/simplification trick is to use LEA to calculate different number variations.

Read http://www.asmcommunity.net/board/index.php?action=dlattach;topic=25770.0;attach=2256 this for further information.

[frktons]

You can use a various combination of constants, the assembler will calculate it for you and put it into the executable. But you cant use registers, that requires the use of special instructions like MUL or DIV.

An optimization/simplification trick is to use LEA to calculate different number variations.

Read http://www.asmcommunity.net/board/index.php?action=dlattach;topic=25770.0;attach=2256 this for further information.

Very interesting, thanks.

So I could do something like:

Code Select Expand


mov ebx, 12
lea    eax, [ebx +13 * 127]
?


This document is part 1 for using lea, do you know if there is also a part 2/...?

Well, I found it. NO problem.

Frank

[zemtex]

You can use a various combination of constants, the assembler will calculate it for you and put it into the executable. But you cant use registers, that requires the use of special instructions like MUL or DIV.

An optimization/simplification trick is to use LEA to calculate different number variations.

Read http://www.asmcommunity.net/board/index.php?action=dlattach;topic=25770.0;attach=2256 this for further information.

Very interesting, thanks.

So I could do something like:

Code Select Expand


mov ebx, 12
lea    eax, 13 * 127
add   eax, ebx
?


This document is part 1 for using lea, do you know if there is also a part 2/...?

Frank

You could replace "lea eax, 13 * 127" with an ordinary move like:
mov eax, 13 * 127... Thats not a problem at all. As long as you use known constants that the assembler can precalculate at assembly time, it does not produce a problem. Since registers are unknown in assembly time you cannot use registers in replacement of constants in the example above.

About the latter document, I do not know (Sorry about that).

Consider LEA as a "trickster", it is not meant to be used regularly for that purpose. You can only multiply registers with 2, 4 and 8 using lea. It is just an option if you want to simplify things every now and then.

Here are a few examples.

These are perfectly legal:

mov eax, 10 + 10
mov eax, 10 * 20 * 30 * 40 * 50 / 100
mov eax, 100 - 20 / 40

These are not legal:

mov eax, 10 + ecx
mov eax, ecx - 100 / 20
mov eax, ecx + 1

And yes, both examples in the first post of yours are legal.

[Antariy]

Frank this is link to thread which contain both documents: "http://www.asmcommunity.net/board/index.php?topic=25770.0"

This is link to part2 directly: "http://www.asmcommunity.net/board/index.php?action=dlattach;topic=25770.0;attach=2257"



Alex

[redskull]

One of the most subtle yet important distinctions to make when learning ASM is to differentiate between what the assembler is doing for you at build time and what the CPU is doing at run-time.  I spent many nights banging my head against the wall trying to figure out why something wouldn't work.

-r

[frktons]

One of the most subtle yet important distinctions to make when learning ASM is to differentiate between what the assembler is doing for you at build time and what the CPU is doing at run-time.  I spent many nights banging my head against the wall trying to figure out why something wouldn't work.

-r

I suppose you mean these expressions are calculated at assemble time, not at runtime?

They become constant numbers for the entire program, don't they?

[Antariy]

Frank, see 2 posts above - I give link to document which you request :P



Alex

[frktons]

Frank, see 2 posts above - I give link to document which you request :P
Alex

Thanks Alex, I had already found it searching with Google.  :P
Frank

[Antariy]

Frank, see 2 posts above - I give link to document which you request :P
Alex

Thanks Alex, I had already found it searching with Google.  :P
Frank

But I'm found it not in Google :P


Alex

[redskull]

They become constant numbers for the entire program, don't they?

Yes, but sometimes it's not as clear cut.  For example, the following is a completly legal statment:

MOV EAX, [EBX+30+ECX*(2*2+4)+100*10-60]

-r

[frktons]

Yes, but sometimes it's not as clear cut.  For example, the following is a completly legal statment:

MOV EAX, [EBX+30+ECX*(2*2+4)+100*10-60]

-r

This brings another question: precedence of operations in expressions.
this: (2*2+4) and this 100*10-60 are calculated from left to right anyway?
what happens if the operands are switched: (4+2*2) is the same of (2*2+4)?

What are the rules?

Frank

[Antariy]

They become constant numbers for the entire program, don't they?

Yes, but sometimes it's not as clear cut.  For example, the following is a completly legal statment:

MOV EAX, [EBX+30+ECX*(2*2+4)+100*10-60]

-r

Frank, dont swoon :) this is:

Code Select Expand


MOV EAX, [EBX+ECX*8+970]



Try make simple parsing, and you see what this is not very hard.


Alex

[redskull]

What are the rules?

parenthesis, multiplecation/division, addition/subtraction.  So, 2*2+4 is the same as 4+2*2.  However, (2*2)+4 is NOT the same as 2*(2+4)

-r

[frktons]

What are the rules?

parenthesis, multiplecation/division, addition/subtraction.  So, 2*2+4 is the same as 4+2*2.  However, (2*2)+4 is NOT the same as 2*(2+4)

-r

Good, usual priority as other languages :U

Thanks