Difference between revisions of "SPO600 64-bit Assembly Language Lab"

From CDOT Wiki
Jump to: navigation, search
(Group Lab Tasks)
(35 intermediate revisions by the same user not shown)
Line 1: Line 1:
 
[[Category:SPO600 Labs]][[Category:Assembly Language]]
 
[[Category:SPO600 Labs]][[Category:Assembly Language]]
 
 
{{Admon/lab|Purpose of this Lab|In this lab, you will experiment with assembler on the x86_64 and aarch64 platforms.}}
 
{{Admon/lab|Purpose of this Lab|In this lab, you will experiment with assembler on the x86_64 and aarch64 platforms.}}
{{Admon/tip|Australia and Red|Perform this lab on [[SPO600_Servers#AArch64:_Australia|Australia]] or your own system (for x86_64) and on [[SPO600_Servers#AArch64:_Red|Red]] (for Aarch64).}}
+
{{Admon/tip|SPO600 Servers|Perform this lab on [[SPO600 Servers]] (you may use your own x86_64 system if desired, along with the AArch64 server).}}
  
 
== Lab 5 ==
 
== Lab 5 ==
 
<!--
 
 
### THIS COMMENTED-OUT SECTION DESCRIBES THE
 
### CONFIGURATION USED FOR THE WINTER 2014
 
### OFFERING OF THE SPO600 COURSE, WHERE THE
 
### AARCH64 WORK WAS DONE IN EMULATION ALONGSIDE
 
### THE X86_64 WORK ON THE INTEL HOST "IRELAND".
 
### IN FALL 2014, AARCH64 HARDWARE WAS AVAILABLE,
 
### AND IRELAND HAD FAILED, SO WE SWITCHED TO
 
### THOSE HOSTS.
 
 
=== 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 [[SPO600 aarch64 QEMU on Ireland|use an emulation environment to build and run aarch64 binaries]].
 
 
The directory <code>~/arm64/spo600/examples</code>, which is also accessible as <code>~/spo600-examples</code>, 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 and Makefiles|make]]'' whenever possible.
 
 
-->
 
  
 
=== Code Examples ===
 
=== Code Examples ===
  
The code examples for this lab are available at this link: http://england.proximity.on.ca/spo600/spo600-lab5-examples.tgz
+
The code examples for this lab are available in the file <code>/public/spo600-assembler-lab-examples.tgz</code> on the [[SPO600 Servers]].
 
 
Please download this archive to your accounts on the x86_64 and Aarch64 systems, and unpack the archive on both systems.
 
  
 
Unpacking the archive in your home directory will produce the following directory structure:
 
Unpacking the archive in your home directory will produce the following directory structure:
Line 61: Line 23:
 
         |      `-- Makefile
 
         |      `-- Makefile
 
         `-- c                    # Portable C versions
 
         `-- c                    # Portable C versions
             |-- hello2.c          # syscall wrapper version
+
             |-- hello2.c          # write() version
             |-- hello.c          # printf version
+
            |-- hello3.c          # syscall() wrapper version
 +
             |-- hello.c          # printf() version
 
             `-- Makefile
 
             `-- Makefile
  
 
Throughout this lab, take advantage of ''[[make and Makefiles|make]]'' whenever possible.
 
Throughout this lab, take advantage of ''[[make and Makefiles|make]]'' whenever possible.
  
=== References ===
+
=== Resources ===
 
* [[Assembler Basics]]
 
* [[Assembler Basics]]
** [[x86_64 Register and Instruction Quick Start]]
+
* [[Syscalls]]
** [[aarch64 Register and Instruction Quick Start]]
+
* [[x86_64 Register and Instruction Quick Start]]
 +
* [[aarch64 Register and Instruction Quick Start]]
  
 
=== Group Lab Tasks ===
 
=== 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.
+
{{Admon/tip|Shortcut|To save lab time '''your group can decide''' to do steps 1-4 as individual homework after the lab.}}
 +
 
 +
1. Build and run the three C versions of the program for x86_64. Take a look at the differences in the code.
  
2. Review, build, and run the x86_64 assembly language programs. Make sure you understand the code.
+
2. Use the <code>objdump -d</code> command to dump (print) the object code (machine code) and disassemble it into assembler for each of the binaries. Find the <code><nowiki><main></nowiki></code> section and take a look at the code. Notice the total amount of code.
  
4. Build and run the C versions of the program for aarch64. Verify that you can disassemble the object code in the ELF binary using <code>objdump -d</code>
+
3. Review, build, and run the x86_64 assembly language programs. Take a look at the code using <code>objdump -d '''objectfile'''</code> and compare it to the source code. Notice the absence of other code (compared to the C binary, which had a lot of extra code).
  
5. Review, build, and run the aarch64 assembly language programs. Make sure you understand the 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 <code>objdump -d '''objectfile'''</code> and take a look at the 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:
+
5. Review, build, and run the aarch64 assembly language programs. Take a look at the code using <code>objdump -d '''objectfile'''</code> and compare it to the source code.
 +
 
 +
6. Here is a basic loop in AArch64 assembler - this loops from 0 to 9, using r19 as the index (loop control) counter:
  
 
  .text
 
  .text
  .globl   _start
+
  .globl _start
 
   
 
   
  start = 0                       /* starting value for the loop index */
+
  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) */
+
  max = 30                        /* loop exits when the index hits this number (loop condition is i<max) */
 
   
 
   
 
  _start:
 
  _start:
     mov    $start,%r15        /* loop index */
+
 +
     mov    x19, min
 
   
 
   
 
  loop:
 
  loop:
    /* ... body of the loop ... do something useful here ... */
 
 
   
 
   
     inc    %r15                /* increment index */
+
     /* '''... body of the loop ... do something useful here ...''' */
     cmp    $max,%r15          /* see if we're done */
+
     jne    loop                /* loop if we're not */
+
    add    x19, x19, 1
 +
     cmp    x19, max
 +
     b.ne    loop
 
   
 
   
     mov    $0,%rdi            /* exit status */
+
     mov    x0, 0           /* status -> 0 */
     mov    $60,%rax            /* syscall sys_exit */
+
     mov    x8, 93          /* exit is syscall #93 */
     syscall
+
     svc    0              /* invoke syscall */
 +
 
 +
This code doesn't actually do anything while looping, because the body of the loop is empty. On an AArch64 machine, combine this code with code from the "Hello World" assembley-language example, so that it prints a word each time it loops:
 +
 
 +
Loop
 +
Loop
 +
Loop
 +
Loop
 +
Loop
 +
Loop
 +
Loop
 +
Loop
 +
Loop
 +
Loop
  
Extend this code, combining it with code from the "Hello World" example, so that it prints each digit from 0 to 9 like this:
+
Then modify the message so that it includes the loop index values, showing each digit from 0 to 9 like this:
  
 
  Loop: 0
 
  Loop: 0
Line 117: Line 100:
 
  Loop: 9
 
  Loop: 9
  
{{Admon/tip|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, which is probably the best approach, or you can perform a sequence of writes for the thee parts of the message ('Loop: ', number, '\n').}}
+
{{Admon/tip|Character conversion|In order to print the loop index value, you will need to convert from an integer to digit character. In ASCII/ISO-8859-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, which is probably the best approach, or you can perform a sequence of writes for the thee parts of the message ('Loop: ', number, '\n'). You may want to refer to the manpage for <code>ascii</code>.}}
 +
 
 +
7. Repeat step 6 for x86_64.
  
7. Repeat step 6 for aarch64.
+
For reference, here is the loop code in x86_64 assembler:
 +
 
 +
.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
  
8. Extend the code to loop from 00-30, printing each value as a 2-digit decimal number.
+
8. Extend the AArch64 code to loop from 00-30, printing each value as a 2-digit decimal number.
  
 
{{Admon/tip|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 <code>div</code> 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.}}
 
{{Admon/tip|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 <code>div</code> 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.
+
9. Repeat step 8 for x86_64.
  
 
=== Deliverables ===
 
=== Deliverables ===

Revision as of 16:55, 21 February 2020

Lab icon.png
Purpose of this Lab
In this lab, you will experiment with assembler on the x86_64 and aarch64 platforms.
Idea.png
SPO600 Servers
Perform this lab on SPO600 Servers (you may use your own x86_64 system if desired, along with the AArch64 server).

Lab 5

Code Examples

The code examples for this lab are available in the file /public/spo600-assembler-lab-examples.tgz on the SPO600 Servers.

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          # write() version
            |-- hello3.c          # syscall() wrapper version
            |-- hello.c           # printf() version
            `-- Makefile

Throughout this lab, take advantage of make whenever possible.

Resources

Group Lab Tasks

Idea.png
Shortcut
To save lab time your group can decide to do steps 1-4 as individual homework after the lab.

1. Build and run the three 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 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 (compared to the C binary, which had a lot of extra 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 objectfile and compare it to the source code.

6. Here is a basic loop in AArch64 assembler - this loops from 0 to 9, using r19 as the index (loop control) counter:

.text
.globl _start

min = 0                          /* starting value for the loop index; note that this is a symbol (constant), not a variable */
max = 30                         /* loop exits when the index hits this number (loop condition is i<max) */

_start:

    mov     x19, min

loop:

    /* ... body of the loop ... do something useful here ... */

    add     x19, x19, 1
    cmp     x19, max
    b.ne    loop

    mov     x0, 0           /* status -> 0 */
    mov     x8, 93          /* exit is syscall #93 */
    svc     0               /* invoke syscall */

This code doesn't actually do anything while looping, because the body of the loop is empty. On an AArch64 machine, combine this code with code from the "Hello World" assembley-language example, so that it prints a word each time it loops:

Loop
Loop
Loop
Loop
Loop
Loop
Loop
Loop
Loop
Loop

Then modify the message so that it includes the loop index values, showing 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
Idea.png
Character conversion
In order to print the loop index value, you will need to convert from an integer to digit character. In ASCII/ISO-8859-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, which is probably the best approach, or you can perform a sequence of writes for the thee parts of the message ('Loop: ', number, '\n'). You may want to refer to the manpage for ascii.

7. Repeat step 6 for x86_64.

For reference, here is the loop code in x86_64 assembler:

.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

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

Idea.png
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 x86_64.

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