In my last post we went through writing a program for printing a message with a 2 digit incrementing value in AArch64 assembly. This time, we're going to tackle the same thing on an x86_64 architecture system.
Starting with the original code we're given:
.text
.globl _start
min = 0 /* starting value for the loop index; note that this is a symbol (constant), not a variable */
max = 10 /* loop exits when the index hits this number (loop condition is i<max) */
_start:
mov $min,%r15 /* loop index */
loop:
/* ... body of the loop ... do something useful here ... */
inc %r15 /* increment index */
cmp $max,%r15 /* see if we're done */
jne loop /* loop if we're not */
mov $0,%rdi /* exit status */
mov $60,%rax /* syscall sys_exit */
syscall
First we need to add logic to print a message, like so:
.text
.globl _start
min = 0 /* starting value for the loop index; note that this is a symbol (constant), not a variable */
max = 10 /* loop exits when the index hits this number (loop condition is i<max) */
_start:
mov $min,%r15 /* loop index */
loop:
mov $len,%rdx /* message length */
mov $msg,%rsi /* message location */
mov $1,%rdi /* file descriptor stdout */
mov $1,%rax /* syscall sys_write */
syscall
inc %r15 /* increment index */
cmp $max,%r15 /* see if we're done */
jne loop /* loop if we're not */
mov $0,%rdi /* exit status */
mov $60,%rax /* syscall sys_exit */
syscall
.section .data
msg: .ascii "Loop\n"
len = . - msg
By adding the provided text output code as above we get the following output:
Loop
Loop
Loop
Loop
Loop
Loop
Loop
Loop
Loop
Loop
Now by adding logic to iterate an index and add it to the msg string, we get the following:
.text
.globl _start
min = 0 /* starting value for the loop index; note that this is a symbol (constant), not a variable */
max = 10 /* loop exits when the index hits this number (loop condition is i<max) */
_start:
mov $min,%r15 /* loop index */
loop:
mov %r15,%r14
add $'0',%r14
movb %r14b,msg+6
mov $len,%rdx /* message length */
mov $msg,%rsi /* message location */
mov $1,%rdi /* file descriptor stdout */
mov $1,%rax /* syscall sys_write */
syscall
inc %r15 /* increment index */
cmp $max,%r15 /* see if we're done */
jne loop /* loop if we're not */
mov $0,%rdi /* exit status */
mov $60,%rax /* syscall sys_exit */
syscall
.section .data
msg: .ascii "Loop: #\n"
With the resulting output:
Loop: 0
Loop: 1
Loop: 2
Loop: 3
Loop: 4
Loop: 5
Loop: 6
Loop: 7
Loop: 8
Loop: 9
Finally, we'll move to printing a 2 digit index along with our loop by making the following changes:
.text
.globl _start
min = 0 /* starting value for the loop index; note that this is a symbol (constant), not a variable */
max = 15 /* loop exits when the index hits this number (loop condition is i<max) */
_start:
mov $min,%r15
mov $10,%r13
loop:
mov %r15,%rax
mov $0,%rdx
div %r13
cmp $0,%rax
je secondDigit
add $'0',%rax
mov %rax,%r12
movb %r12b,msg+6
secondDigit:
add $'0',%rdx
mov %rdx,%r12
movb %r12b,msg+7
mov $len,%rdx /* message length */
mov $msg,%rsi /* message location */
mov $1,%rdi /* file descriptor stdout */
mov $1,%rax /* syscall sys_write */
syscall
inc %r15 /* increment index */
cmp $max,%r15 /* see if we're done */
jne loop /* loop if we're not */
mov $0,%rdi /* exit status */
mov $60,%rax /* syscall sys_exit */
syscall
.section .data
msg: .ascii "Loop: #\n"
len = . - msg
Which gets us the appropriate output:
Loop: #0
Loop: #1
Loop: #2
Loop: #3
Loop: #4
Loop: #5
Loop: #6
Loop: #7
Loop: #8
Loop: #9
Loop: #10
Loop: #11
Loop: #12
Loop: #13
Loop: #14
Loop: #15
Loop: #16
Loop: #17
Loop: #18
Loop: #19
Loop: #20
Loop: #21
Loop: #22
Loop: #23
Loop: #24
Loop: #25
Loop: #26
Loop: #27
Loop: #28
Loop: #29
Loop: #30
Again this looks like the output we're looking for, so I'll break down how we got here and leave some parting thoughts on writing assembly programs for x86_64 vs my experience writing for AArch64.
_start:
mov $min,%r15
mov $10,%r13
Starting off with the start section, we move the value of min to r15 and set r13 to 10, which we'll use to divide and split our 2 digits. Remember in this syntax the destination register is placed on the right, contrary to how it was arranged in the AArch64 program.
loop:
mov %r15,%rax
mov $0,%rdx
div %r13
cmp $0,%rax
je secondDigit
Next we place the value to be divided into rax and clear rdx to accept the remainder, before using the div instruction to divide what's in the rax register. We compare the value placed in rax, our "tens" column, to zero and branch to the secondDigit section if there's no tens column.
add $'0',%rax
mov %rax,%r12
movb %r12b,msg+6
In the first line here we add an ascii 0 to the result of the division, after which we move that to r12 and finally move a byte of that with movb to the address of the pound sign in msg.
secondDigit:
add $'0',%rdx
mov %rdx,%r12
movb %r12b,msg+7
Again here we add an ascii 0, this time to the remainder from the previous division, and then move that to r12 to have a byte moved to the pound sign address in msg. Like the last program, I'll end my breakdown here as the rest is pretty self evident and discuss my experience with x86_64.
This was pretty similar to assembly in AArch64 in a lot of ways, there were some minor syntactical differences like the precedence of operands listed above, and $ and % symbols being used to denote immediate values and registers, respectively. I'd be hard pressed to pick one I prefer, but if I had to I'd lean toward the AArch64 for its syntax, which I find slightly more readable. The difference is pretty negligible though. I also like the philosophy of improvement and not being weighed down by legacy features and nomenclature that comes with x86_64, but that hasn't affected my coding on either to any great extent thus far.
Overall this was a good challenge and I'm looking forward to diving deeper into these architectures.
Top comments (0)