What does mov bl do in assembly

Question

Could you please explain how the following assembler code works?

xor ebx, ebx;
mov bl, byte ptr[ecx];
cmp ebx, 0;

I don't get it why you move byte to bl and afterwards you compare ebx and not bl.

Answer 1

bl is the name of the low 8 bits (bits 7-0) in the ebx register. There is also bh which is the bits 15-8 of ebx, and bx is the low 16 bits (bits 15-0). There is no name for the higher 16 bits.

This applies to all of the registers eax, ebx, ecx and edx.

Given that ebx is first zero'd, the resulting code is probably the consenquence of the compiler doing compiling something like:

char ch;
const char str;
int i;
...
ch = str[i];
if (ch == 0) ... 

[Or possibly just if (ch)].

The extension to 32-bits would be caused by either "saves space" or "runs faster", or the fact that if (ch == 0) has an int on the right-hand side and needs to compare the value as int rather than as char = byte - I can't say which without seeing the original source code - and even then, the actual code-generation in the compiler quite a complex set of decisions, based on both "what runs fast on which processor" and "correctness according to the language".

Answer 2

This instruction peforms an exclusive-or between all 32 bits of EBX and all 32 bits of EBX, leaving the result in EBX. You can prove easily that this is the same as moving the value of 0 into EBX (but it's faster than doing that because this way there are no memory fetches required)

xor ebx, ebx;

This instruction moves the BYTE (8 bits) at the address pointed to by ECX into the LOW 8 bits of EBX, leaving the other 24 bits unchanged (they're zero - remember?)

mov bl, byte ptr[ecx];

This instruction compares the whole 32-bit value in EBX with 0 - in this case it's logically the same as just comparing the byte in BL with 0 since we know the upper 24 bits will be 0

cmp ebx, 0;

(anticipated) why do it this way?

Because this is a 32-bit processor. It's geared to operate on 32-bit values much more efficiently than 8-bit ones. The compiler knows this and will always seek to promote smaller values to larger ones as soon as it is allowed.

Answer 3

BL is the low byte of the EBX register so, since you're xoring EBX before, you're comparing 0 against EBX with its low byte equal to BL.

Answer 4

From a pure end effect perspective, there is no difference between

CMP ebx,0

and

CMP bl,0

in the given situation as there is already an XOR EBX,EBX preceding this group of instructions. The first command is executed after sign extending the imm8 value, so effective comparison, which is executed by executing a subtraction in the temporary registers) is always 32 bit in this case. The opcode lengths are also identical : 80 /7 /ib and 83 /7 /id.

However, from a data bus flow perspective, the data bus is optimized to read a 32 bit data flow faster as it does not have to execute an AND with internal mask to isolate the 8 bits data content of the register, and therefore, it's a recommended practice for assembler writers to use the best possible bus width - which is usually a multiple of 32. Therefore, you would see cmp ebx,0 as the preferred code translation over cmp bl,0.

Have fun programming...