In x86 assembly language, is it possible to obtain the first bit of a register? I want to obtain the first bit of the eax register and move it into ebx, but I'm not sure how to do this yet.
.stack 2048
.data
ExitProcess proto, exitcode:dword
.code
start:
mov eax, 3;
;now I want to move the first bit of eax into ebx. How can I obtain the first bit from eax?
invoke ExitProcess, 0
end start
If by "first bit" you mean the least significant bit, then try:
...
mov ebx, eax
and ebx, 01
You apparently don't understand that instructions operate on all the bits in a named register at once, and the "and" instructions combine their operands bit-by-bit.
The following works, too, and is arguably a more direct interpretation of your request ("get the first bit of eax, and then put in EBX") but it destroys the contents of EAX:
...
and eax, 1
mov ebx, eax
In assembly code, because you have few registers, their contents tend to be precious, so destroying one register's content in computing a new result is generally avoided. (When you can't, you can't, but this case it is easy to avoid).
Finally, you could write:
...
mov ebx, 1
and ebx, eax
This works fine, and is just as fast as the other two. I prefer the first because it emphasizes IMHO the value I care about (content of EAX) by virtue of mentioning it first, over the "1", which is just an incidental constant. This kind of style may not seem like it matters much, but if you write a lot of code, especially arcane stuff such as assembler, doing it to maximize later readability is worth a lot.
It is worth your trouble to find the Intel reference manuals, and read them carefully to understand what each machine instruction does. That seems like a daunting task because its a big book; just focus on the instructions you initially seem to need.
Obtaining a bit from a register involves an and operation with a mask that has a 1 in the bit position of interest, and 0 in all other bits. Then optionally, a rotate right or a rotate left to move the bit into the desired position in the result.
You can also use the rotation properties of assembly, which is to use the bit instruction to copy the specified bit into the carry flag, and we can use the rotation-carry flag instructions.
I think this is very efficient in terms of understanding what is going on when it comes to where and how the blasted bit is being used and placed.
As stated above, using mov and and are the quickest solutions here, but the fun part about programming is that one can find many solutions to a single problem, so as a less efficient alternative, you could use one of the following codes.
So you can also solve it like this:
xor ebx, ebx ; sets ebx = 0
TEST eax, 1 ; is the lowest bit set?
JZ skip_add ; if low bit is zero, skip next instruction
; if lowest bit was set / AND op resulted not zero
add ebx, 1 ; ebx += 1, or use `INC ebx`
skip_add:
; process the result
Alternatively, you can also use:
xor ebx, ebx ; ebx = 0
shr eax, 1 ; shift right: lowest bit in carry flag now
adc ebx, 0 ; ebx += 0 + carry bit
shl eax, 1 ; get back original value of eax, `shl` and `or` with ebx
or eax, ebx ; or use `push eax` and `pop eax` instead
Another alternative (similar to the other answers, but more costy):
push eax
and eax, 1
xchg ebx, eax ; swap contents, could also use `mov` here
pop eax
Note that both solutions do not change the value in eax, so you can still use the value in eax freely. Also note that the commented values are for eax having the value of 3 as mov eax, 3 was used in the question.
If you already know, that ebx is zero, you can skip the xor lines and if changing eax doesn't matter, you can just delete the shl operation as well. So the actual operation is done by about two instructions, as you can see. About the µops, see the comment of Peter, though.
...with the first bit:
test eax, 1
setz ebx
Dirk
