Difference between revisions of "SPO600 64-bit Assembly Language Lab"
Chris Tyler (talk | contribs) (→Group Lab Tasks) |
Chris Tyler (talk | contribs) (→References) |
||
Line 66: | Line 66: | ||
* [[x86_64 Register and Instruction Quick Start]] | * [[x86_64 Register and Instruction Quick Start]] | ||
* [[aarch64 Register and Instruction Quick Start]] | * [[aarch64 Register and Instruction Quick Start]] | ||
+ | * [[Syscalls]] | ||
=== Group Lab Tasks === | === Group Lab Tasks === |
Revision as of 00:55, 20 January 2017
Contents
Lab 3
Code Examples
The code examples for this lab are available in the file /public/spo600-assembler-lab-examples.tgz on both Betty and Xerxes
Unpacking the archive in your home directory will produce the following directory structure:
spo600 `-- examples `-- hello # "hello world" example programs |-- assembler | |-- aarch64 # aarch64 gas assembly language version | | |-- hello.s | | `-- Makefile | `-- x86_64 # x86_64 assembly language versions | |-- hello-gas.s # ... gas syntax | |-- hello-nasm.s # ... nasm syntax | `-- Makefile `-- c # Portable C versions |-- hello2.c # syscall wrapper version |-- hello.c # printf version `-- Makefile
Throughout this lab, take advantage of make whenever possible.
References
- Assembler Basics
- x86_64 Register and Instruction Quick Start
- aarch64 Register and Instruction Quick Start
- Syscalls
Group Lab Tasks
1. Build and run the two C versions of the program for x86_64. Take a look at the differences in the code.
2. Use the objdump -d
command to dump (print) the object code (machine code) and disassemble it into assembler for each of the two binaries. Find the <main>
section and take a look at the code. Notice the total amount of code.
3. Review, build, and run the x86_64 assembly language programs. Take a look at the code using objdump -d objectfile
and compare it to the source code. Notice the absence of other code.
4. Build and run the three C versions of the program for aarch64. Verify that you can disassemble the object code in the ELF binary using objdump -d objectfile
and take a look at the code.
5. Review, build, and run the aarch64 assembly language programs. Take a look at the code using objdump -d
and compare it to the source code.
6. Here is a basic loop in x86_64 assembler - this loops from 0 to 9, using r15 as the index (loop control) counter:
.text .globl _start start = 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 $start,%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
Extend this code, combining it with code from the "Hello World" example, so that it prints each digit from 0 to 9 like this:
Loop: 0 Loop: 1 Loop: 2 Loop: 3 Loop: 4 Loop: 5 Loop: 6 Loop: 7 Loop: 8 Loop: 9
7. Repeat step 6 for aarch64.
8. Extend the code to loop from 00-30, printing each value as a 2-digit decimal number.
9. Repeat step 8 for aarch64.
Deliverables
1. Complete the group lab section, above.
2. Extend the assembler programs (both x86_64 and aarch64) to suppress the high digit when it is 0. In other words, the printed values should progress from 0-30 instead of from 00-30. It is OK to output a space in place of the suppressed digit (this will cause the numbers to be aligned vertically in the output).
3. Blog about the programs you've written. Describe the experience of writing and debugging in assembler, as compared to writing in other languages. Contrast x86_64 and aarch64 assembler, your experience with each, and your opinions of each. Include links to the source code for both of your assembler programs.
Optional Challenge
Write a program in aarch64 assembly language to print the times tables from 1-12 ("1 x 1 = 1" through "12 x 12 = 144"). Add a spacer between each table, and use a function/subroutine to format the numbers with leading-zero suppression.
The output could look something like this:
1 x 1 = 1 2 x 1 = 2 3 x 1 = 3 4 x 1 = 4 5 x 1 = 5 6 x 1 = 6 7 x 1 = 7 8 x 1 = 8 9 x 1 = 9 10 x 1 = 10 11 x 1 = 11 12 x 1 = 12 ------------- 1 x 2 = 2 2 x 2 = 4 3 x 2 = 6 4 x 2 = 8 5 x 2 = 10 ...lines snipped for space... 11 x 12 = 132 ------------- 1 x 12 = 12 2 x 12 = 24 3 x 12 = 36 4 x 12 = 48 5 x 12 = 60 6 x 12 = 72 7 x 12 = 84 8 x 12 = 96 9 x 12 = 108 10 x 12 = 120 11 x 12 = 132 12 x 12 = 144