Introduction and ObjDumps
We are finally stepping into the realm where we start doing stuff with assembly. For lab 4, we compared assembly's version to c's version of a simple hello world programme.
We used to makefile to make a executable of a c programme. When we used objdump -d hello in both aarch64 and x86. For your reference here is the x86's version of the dump which only includes the main part.
0000000000401126 <main>:
401126: 55 push %rbp
401127: 48 89 e5 mov %rsp,%rbp
40112a: bf 10 20 40 00 mov $0x402010,%edi
40112f: b8 00 00 00 00 mov $0x0,%eax
401134: e8 f7 fe ff ff call 401030 <printf@plt>
401139: b8 00 00 00 00 mov $0x0,%eax
40113e: 5d pop %rbp
40113f: c3 ret
Now we did the same for the assembly's version and the main part can be seen below. NOTE: this dump is from x86 and from GNU as assembler.
0000000000401000 <_start>:
401000: 48 c7 c2 0e 00 00 00 mov $0xe,%rdx
401007: 48 c7 c6 00 20 40 00 mov $0x402000,%rsi
40100e: 48 c7 c7 01 00 00 00 mov $0x1,%rdi
401015: 48 c7 c0 01 00 00 00 mov $0x1,%rax
40101c: 0f 05 syscall
40101e: 48 c7 c7 00 00 00 00 mov $0x0,%rdi
401025: 48 c7 c0 3c 00 00 00 mov $0x3c,%rax
40102c: 0f 05 syscall
Assembly code in Aarch64
We were given an incomplete. code below that prints the word loop 10 times. Here is what the completed loop looks like.
.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 x19, min
loop:
mov x0, 1``
adr x1, msg
mov x2, len
mov x8, 64
svc 0
add x19, x19, 1 /* increment the loop counter */
cmp x19, max /* see if we've hit the max */
b.ne loop /* if not, then continue the loop */
mov x0, 0 /* set exit status to 0 */
mov x8, 93 /* exit is syscall #93 */
svc 0 /* invoke syscall */
.data
msg: .ascii "Loop:\n"
len= . - msg
We were also asked to print numbers at the end of the text representing the time of times the loops was ran, below is the code for that
.text
.globl _start
min = 0 /* starting value of the loop idx. this is a symbol */
max = 10 /* ending value of the loop idx. this is a symbol */
prefix = 0
_start:
mov x19, min /* store min to x19, which will be our idx register */
loop:
mov x0, 1 /* file descriptor: 1 is stdout */
adr x1, msg /* message location (memory address) */
mov x2, len /* message length (bytes) */
mov x4, x19 /* copy idx(x19) to x4 */
add x4, x4, 48 /* add 48 to make it ASCII */
strb w4, [x1, 6] /* store 1 byte into the memory loc of msg + 6 */
mov x8, 64 /* write is syscall #64 */
svc 0 /* invoke syscall */
add x19, x19, 1 /* add 1 to idx(x19) */
cmp x19, max /* compare x19 to max */
b.ne loop /* branch if not equal to loop */
mov x0, 0 /* status -> 0 */
mov x8, 93 /* exit is syscall #93 */
svc 0 /* invoke syscall */
.data
msg: .ascii "Loop: 0\n"
len= . - msg
Now the hardest part, we were asked to implement the same logic, but run the loop 30 times. This is challenging because we are now supposed keep a track of 2 variables that is one for ones place and one for second place. Below is the code that I came up with
.text
.globl _start
min = 0 /* starting value of the loop idx. this is a symbol */
max = 3 /* ending value of the loop idx. this is a symbol */
prefix = 0
default = 0
_start:
mov x19, min /* store min to x19, which will be our idx register */
mov x20, prefix
loop:
mov x0, 1 /* file descriptor: 1 is stdout */
adr x1, msg /* message location (memory address) */
mov x2, len /* message length (bytes) */
mov x4, x19 /* copy idx(x19) to x4 */
add x4, x4, 48 /* add 48 to make it ASCII */
cmp x4, 58
b.ne is_not_over
mov x19, default
add x20, x20, 1 /* add 1 to idx(x19) */
is_not_over:
mov x4, x20 /* copy idx(x19) to x4 */
add x4, x4, 48 /* add 48 to make it ASCII */
strb w4, [x1, 6] /* store 1 byte into the memory loc of msg + 6 */
mov x4, x19 /* copy idx(x19) to x4 */
add x4, x4, 48 /* add 48 to make it ASCII */
strb w4, [x1, 7] /* store 1 byte into the memory loc of msg + 7 */
b continue
continue:
mov x8, 64 /* write is syscall #64 */
svc 0 /* invoke syscall */
add x19, x19, 1 /* add 1 to idx(x19) */
cmp x20, max /* compare x19 to max */
b.ne loop /* branch if not equal to loop */
mov x0, 0 /* status -> 0 */
mov x8, 93 /* exit is syscall #93 */
svc 0 /* invoke syscall */
.data
msg: .ascii "Loop: 00\n"
len= . - msg
Lastly, we were supposed to remove the prefix 0 so that the output is more cleaner, this was actually easy, I just added an extra branch
default = 0
_start:
mov x19, min /* store min to x19, which will be our idx register */
mov x20, prefix
loop:
mov x0, 1 /* file descriptor: 1 is stdout */
adr x1, msg /* message location (memory address) */
mov x2, len /* message length (bytes) */
mov x4, x19 /* copy idx(x19) to x4 */
add x4, x4, 48 /* add 48 to make it ASCII */
cmp x4, 58
b.ne is_not_over
mov x19, default
add x20, x20, 1
is_not_over:
mov x4, x20 /* copy idx(x19) to x4 */
cmp x4, 0
b.eq print_ones
add x4, x4, 48 /* add 48 to make it ASCII */
strb w4, [x1, 6] /* store 1 byte into the memory loc of msg + 6 */
print_ones:
mov x4, x19 /* copy idx(x19) to x4 */
add x4, x4, 48 /* add 48 to make it ASCII */
strb w4, [x1, 7] /* store 1 byte into the memory loc of msg + 7 */
b continue
continue:
mov x8, 64 /* write is syscall #64 */
svc 0 /* invoke syscall */
add x19, x19, 1 /* add 1 to idx(x19) */
cmp x20, max /* compare x19 to max */
b.ne loop /* branch if not equal to loop */
mov x0, 0 /* status -> 0 */
mov x8, 93 /* exit is syscall #93 */
svc 0 /* invoke syscall */
.data
msg: .ascii "Loop: 0\n"
len= . - msg
Assembly code in x86
For this part I was supposed to do everything I did for arch in x86, So save some time I will plug the final code here.
.globl _start
min = 0 /* starting value for the loop index; **note that this is a symbol (constant)**, not a variable */
max = 3 /* loop exits when the index hits this number (loop condition is i<max) */
prefix = 0
default = 0
_start:
mov $min,%r15 /* loop index */
mov $prefix,%r12
loop:
movq $len,%rdx /* message length */
movq $msg,%rsi /* message location */
mov %r15, %r14
add $48, %r14
movq %r15, %r14
add $48, %r14
cmp $58, %r14 /* Compare r14 with ASCII value of '9' (which is 57) */
jne not_overflow
inc %r12
movq $default,%r15
not_overflow:
movq %r15, %r14
add $48, %r14
add $7, %rsi /* Move to the 5th index of the message */
movb %r14b, (%rsi)
sub $7, %rsi
movq %r12, %r14
add $48, %r14
cmp $48, %r14 /* Compare r14 with ASCII value of '9' (which is 57) */
je continue
add $6, %rsi /* Move to the 5th index of the message */
movb %r14b, (%rsi)
sub $6, %rsi
continue:
movq $1,%rdi /* file descriptor stdout */
movq $1,%rax /* syscall sys_write */
syscall
inc %r15 /* increment the loop index */
cmp $max,%r12 /* see if we've hit the max */
jne loop /* if not, then continue the loop */
mov $0,%rdi /* set exit status to 0 */
mov $60,%rax /* exit is syscall #60 */
syscall
.section .data
msg: .ascii "Loop: 0\n"
len = . - msg
Conclusion
This lab was an engaging exploration of assembly language programming across both AArch64 and x86 architectures. The stark differences in syntax and structure between the two made for a fascinating challenge, allowing me to appreciate the unique characteristics of each assembly language. I found the AArch64 assembly to be more intuitive, which made debugging feel somewhat more manageable compared to x86.
Completing the task of implementing loops with varying output formats sharpened my understanding of low-level programming concepts, particularly in relation to system calls and data handling.
Top comments (1)
This lab was a great introduction to assembly! It's fascinating to see how simple tasks like printing "Hello, World!" are handled at such a low level. I especially enjoyed the AArch64 assembly - it felt more intuitive than x86 for debugging.