SPO600 64-bit Assembly Language Lab

Purpose of this Lab
In this lab, you will experiment with assembler on the x86_64 and aarch64 platforms.

Ireland
Perform this lab on ireland.proximity.on.ca.)

Lab 3

Ireland - Configuration

The host Ireland (ireland.proximity.on.ca) has been set up so that you can use it normally as an x86_64 host, or use an emulation environment to build and run aarch64 binaries.

The directory ~/arm64/spo600/examples, which is also accessible as ~/spo600-examples, contains these files:

── hello                         # 'hello world' example programs
   ├── assembler
   │   ├── aarch64               # aarch64 assembler version
   │   │   ├── hello.s
   │   │   └── Makefile
   │   └── x86_64                # x86_64 assembler versions
   │       ├── hello-gas.s       # 64-bit instructions with AT&T/gnu assembler syntax (called 'gas', /usr/bin/as)
   │       ├── hello-nasm.s      # 32-bit instructions with Intel/nasm assembler syntax (/usr/bin/nasm)
   │       └── Makefile
   └── c
       ├── hello2.c              # C version using the write() syscall wrapper
       ├── hello.c               # C version using printf()
       └── Makefile

Throughout this lab, take advantage of make whenever possible.

Group Lab Tasks

1. Build and run the C versions of the program for x86_64.

2. Review, build, and run the x86_64 assembler code. Make sure you understand the code.

4. Build and run the C versions of the program for aarch64 (note: you may need to make clean).

5. Review, build, and run the aarch64 assembler code. Make sure you understand the code.

6. Here is a basic loop in x86_64 assembler:

.text
.globl    _start

start = 0                       /* starting value for the loop index */
max = 10                        /* loop exits when the index hits this number (loop condition is i<max) */

_start:
    mov     $start,%r15             /* loop index */

loop:
    /* ... do something useful here ... */

    inc     %r15                /* increment register 15 */
    cmpq    $10,%r15            /* see if we're done */
    jne     loop                /* loop if we're not */

    movq    $0,%rdi             /* exit status */
    movq    $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

Character conversion
In order to print the loop index value, you will need to convert from an integer to digit character. In ASCII/ISO-9959-1/Unicode UTF-8, the digit characters are in the range 48-57 (0x30-0x39). You will also need to assemble the message to be printed for each line - you can do this by writing the digit into the message buffer before outputting it to stdout, or you can perform a sequence of writes for the various portions of the message.

7. Repeat step 6 for aarch64.

8. Extend the code to loop from 00-30, printing each value as a 2-digit decimal number.

2-Digit Conversion
You will need to take the loop index and convert it to a 2-digit decimal number by dividing by 10. To do this, use the div instruction, which takes the dividend from rax and the divisor from register supplied as an argument. The quotient will be placed in rax and the remainder will be placed in rdx.

9. Repeat step 8 for aarch64.

Deliverable

1. Complete the group lab section, above.

2. Extend the assembler programs (both x86_64 and aarch64) to suppress the high digits when they are 0. In other words, the printed values should progress from 0-30 instead of from 00-30.

3. Blog about the programs you've written. Describe the experience of writing in assembler, as compared to writing in other languages. Contrast x86_64 and aarch64 assembler, and your experience with each.