Assembly do we need the endings? [duplicate]

Question

In assembly (att) the following is legal:

mov %rax, %rbx

which is equal to:

movq %rax, %rbx

Where q means the first parameter is 64 bits, my question is:

Is this q (or other endings) used only for simplicity of human reading or there could be some cases where no writing q would give wrong answer or different result than the expected one or even crash the code (illegal command), please give me an example if possible.

Answer 1

You're asking about the operand size suffix. There are two cases:

1. For many instructions, the operand size can be inferred from the operands themselves, typically because they are registers of a particular size. This is like your example: mov %rax, %rbx must have a 64-bit operand size, because %rax, %rbx are 64-bit registers. In this case, the suffix is optional, and the same machine code (48 89 c3) is generated whether you write mov %rax, %rbx or movq %rax, %rbx. It's purely a matter of style whether you choose to include it or not (though certainly people have opinions about which way is better).

   If you provide a suffix that is inconsistent with the operands, e.g. movl %rax, %rbx, the assembler will give a warning or error.

2. In others, the operand size cannot be inferred. The most common case is when one operand is an immediate and the other is a memory reference. If you write mov $1, (%rbx) for ecm's example from comments, it is ambiguous: should the assembler emit an instruction to store a byte (machine code c6 03 01), or a word (two bytes, 66 c7 03 01 00), or a long (four bytes, c7 03 01 00 00 00), or a quad (eight bytes, 48 c7 03 01 00 00 00)? So a suffix is required in this case: you must write movb $1, (%rbx) or movw $1, (%rbx) and so on.

   If you omit the suffix in such a case, recent assembler versions should at least warn you. Some will then abort with an error; others may guess at the operand size or use some built-in default, as Peter comments below. Some older assembler versions would actually revert to a default without warning.

So in principle, yes, omitting the suffix could lead to "wrong" code, in some cases and with some assemblers. However, current versions of the widely used AT&T-syntax assemblers would at least warn you.

There is however one other way that this can sort of happen: suppose you want to add 5 to the 32-bit register eax (addl $5, %eax), but you make a typo and leave off the e. If you are in the habit of using the suffixes, you would write addl $5, %ax and get an assembly error, alerting you to your mistake. If your style is to omit them, you would write add $5, %ax and the code would build perfectly but would be "wrong".