-1

I'm looking to load a string byte by byte to check for a null value that signifies the termination of that string in x86. I had prior done this in ARM using ldrb as such:

loop:
    ldrb    r1, [r0], #1 //Load next byte of string into r0
    cmp     r1, #0 //Check this byte against 0
    beq     end //If the byte is equal stop and print
    //... Other operations omitted  
    b       loop//Branch back to top

In this example r0 holds the string and ldrb is used to load the next 1 byte into r1 per loop cycle. I'd be looking to do roughly the same thing in x86

user3210373
  • 33
  • 1
  • 1
  • 3

1 Answers1

2

Surely you have an instruction set reference. There is really no way around knowing the basic data movement and comparison instructions. You shouldn't rely on being spoon-fed.

That said, the x86 counterpart to ldrb is called movzbl (move zero extended byte to long, called movzx in intel syntax). Here is a sample implementation using eax for r0 and edx for r1:

loop:
    movzbl 1(%eax), %edx
    cmpl $0, %edx
    je end
    // ... other operations omitted
    jmp loop

Also note that x86 is CISC and supports operating on memory directly, meaning you can compare a value in memory to 0 without loading into a register. You can use that if you don't need the value of the character.

Furthermore, certain parts of x86 registers can be used directly, in this case you could write movb 1(%eax), %dl to use the low 8 bits of %edx. The top 24 bits then stay unchanged, so you should only use byte-sized comparison too.

Speaking of the comparison, common idioms for zero testing include using and, or or test instructions with both operands being the register in question, such as test %edx, %edx. This is done because these produce shorter machine code.

Jester
  • 56,577
  • 4
  • 81
  • 125
  • Thanks, everything seems to be in order now. I really appreciate it! I do have an instruction set reference but, it's a bit convoluted, I spent the past day or so trying to figure it out. – user3210373 Dec 01 '14 at 00:49