4

Possible Duplicate:
What's the purpose of the LEA instruction?

When I need the value at an address I can use the effective address e.g. push dword [str+4]. But when I need to reference an address -- I can't use push dword str+4 (which to me is the obvious and intiutive way to do it).

Instead need to use lea EAX, [str+4] and then push EAX. This a bit confusing and also gives an extra processor instruction, albeit a 'zero-clock' one. (See this answer)

Is there some hardware level explaination for this difference, or is it just a quirk of (NASM) assembly syntax?

Edit: Okay so this comment asks the same question as me. And it is answered in this comment just as Lucero's answer - the X86 does not support such addressing.

Community
  • 1
  • 1
qff
  • 5,524
  • 3
  • 37
  • 62
  • I would guess it's because x86 is horrible (albeit successful). – zneak Aug 18 '12 at 12:34
  • The answer you are linking to says that it *used to be* free, beause it used dedicated address generation logic on some earlier x86 CPUs. Some of the x86 instructions are just for historical reasons and have *widely* different performance on various hardware generations. – Bo Persson Aug 18 '12 at 15:45
  • In my opinion this question is not the same as [its assigned duplicate](http://stackoverflow.com/questions/1658294/whats-the-purpose-of-the-lea-instruction), though the comments of the question contains this question and it's answer. I suggest a question title change to 'Alternative syntax for the LEA instruction' or something to that effect. – qff Aug 20 '12 at 12:00

4 Answers4

4

Just use the correct syntax, you need the offset keyword:

 push offset str+4

The LEA instruction is handy to use the plumbing of the address generation logic. Giving very cheap ways to add and multiply that don't use the ALU. High on the list of tricks for programmers that write code generators. Not needed here, afaict.

Hans Passant
  • 922,412
  • 146
  • 1,693
  • 2,536
  • The `offset` keyword doesn't seem to be available in NASM, so maybe this discrepancy simply _is_ a quirk of NASM. From reading [this source](http://rs1.szif.hu/~tomcat/win32/intro.txt) though - it seems that `offset` will use a `lea` in order to generate the address. (See the 'DATA offset vs DATA contents' part) – qff Aug 19 '12 at 23:25
2

This is more of a long comment (since it doesn't answer the question), but readers ought to know..

lea most certainly is not a zero-clock instruction. There are some of those, such as fxch (on everything with register renaming), nop (90 and 0F 1F) on Sandy Bridge, and certain idioms for setting a register to zero (xor or sub with itself, even for XMM registers), also on Sandy Bridge. They still have a limited throughput, of course, so they're not free.

lea always takes at least one cycle (at least, on any processor I know, and it may not always have been this way), it is commonly executed on an ALU instead of an AGU (some AMD's and Atom are exceptions) but even in the cases where it's executed on an AGU it still takes a cycle or more. lea can even take more than 1 cycle, such as scaled lea on P4, Sandy Bridge (seems like I'm mentioning SB a lot in this post..) or AMD processors. In fact, on AMD K10 the lea that goes to the AGU is the slow case, where it's scaled and/or has 3 arguments and takes a cycle longer than the fast one, which goes to an ALU.

harold
  • 61,398
  • 6
  • 86
  • 164
0

Assembly instructions directly represent x86 opcodes (no transforming compilation takes place as in higher-level languages). The opcodes have their limitations in what they can represent; as such, while address computations are possible as part of the x86 adressing, value computations are not. LEA covers this gap by storing the result of the address computation in any register instead of only consuming it internally.

Lucero
  • 59,176
  • 9
  • 122
  • 152
0

Because that starts to look like C. The only place you can use that sort of inline addition is when addressing memory. LEA lets you "address" memory without addressing it, which can be very useful in protected mode where a small pointer misstep will kill your application (and maybe even better in real mode where a pointer misstep might kill DOS, Windows, the machine, and kill any number of things). Assembly is a limited beast in which each instruction corresponds to a physical circuit. That the instructions are a general as they are is a small miracle of its own.

Linuxios
  • 34,849
  • 13
  • 91
  • 116