[[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/tip|Australia and RedSPO600 Servers|Perform this lab on <code>australia.proximity.on.ca</code> [[SPO600 Servers]] (for x86_64) you may use your own systems if they are of the right architecture and red (for aarch64, accessed via port 2222 on <code>iraq.proximity.on.ca</code>appropriately configured).}}
== Lab 3 4 ==
<!--=== Code Examples ===
### THIS COMMENTEDThe code examples for this lab are available in the file <code>/public/spo600-OUT SECTION DESCRIBES THE ### CONFIGURATION USED FOR THE WINTER 2014 ### OFFERING OF THE assembler-lab-examples.tgz</code> on each 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 HOSTSServers]].
=== Ireland 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 │ ├── Makefile │ └── x86_64 # x86_64 assembly language versions │ ├── hello- Configuration ===gas.s # ... gas syntax │ ├── hello-nasm.s # ... nasm syntax │ └── Makefile └── c # Portable C versions ├── hello2.c # ... using write() ├── hello3.c # ... using syscall() ├── hello.c # ... using printf() └── Makefile
The host ''IrelandThroughout this lab, take advantage of '' (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 Irelandmake and Makefiles|use an emulation environment to build and run aarch64 binariesmake]]'' whenever possible.
The directory <code>~/arm64/spo600/examples</code>, which is also accessible as <code>~/spo600-examples</code>, contains these files:=== Resources ===* [[Assembler Basics]] (includes instructions on how to use the GNU Assembler)* [[Syscalls]]* [[x86_64 Register and Instruction Quick Start]]* [[aarch64 Register and Instruction Quick Start]]
── 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=== Optional Investigation ===
Throughout this lab, take advantage 1. Build and run the three C versions of ''[[make the program for x86_64 and Makefiles|aarch64, using <code>make]]'' whenever possible</code>. Take a look at the differences in 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. Also notice the total amount of code.
=== Code Examples ===3. Review, build, and run the x86_64 assembly language programs using <code>make</code>, taking note of the commands that are executed to assemble and link the code. 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).
The 4. Build and run the assembly language version of the program for aarch64 using <code examples for this lab >make</code>, taking note of the commands that are available at this executed to assemble and link: http://englandthe code.proximity.on.caVerify that you can disassemble the object code in the ELF binary using <code>objdump -d ''objectfile''</spo600/spo600-lab3-examplescode> and take a look at the code.tgz
Please download this archive to your accounts on Australia and Red, and unpack the archive on both systems. Do all of the work for the x86_64 architecture on Australia, and all of the work on the aarch64 architecture on Red.=== Lab Tasks ===
Unpacking <!-- {{Admon/tip|Answers in the Video!|The answers to the archive first three steps below are contained in your home directory will produce the following directory structureassociated [https://web.microsoftstream.com/video/8c3c1353-5729-4217-b1ba-371410f14ad4 lecture video.]}} -->
spo600 `-- examples `-- hello # "hello world" example programs |-- assembler | |-- aarch64 # 1. Review, build, and run the aarch64 gas assembly language version | | |-- hello.s | | `-- Makefile | `-- x86_64 # x86_64 assembly language versions | |-- hello-gas.s # ... gas syntax | |-- hello-nasm.s # ..programs. nasm syntax | `-- Makefile `-Take a look at the code using <code>objdump - c # Portable C versions |-- hello2d '''objectfile'''</code> and compare it to the source code.c # syscall wrapper version |-- hello.c # printf version `-- Makefile
Throughout 2. Here is a basic loop in AArch64 assembler - this labloops from 0 to 9, take advantage of ''[[make and Makefiles|make]]'' whenever possible.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 == References ===10 /* 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 * [[Assembler Basics]]/ mov x8, 93 /*exit is syscall #93 * [[x86_64 Register and Instruction Quick Start]]/ svc 0 /*invoke syscall * [[aarch64 Register and Instruction Quick Start]]/
=== Group Lab Tasks ===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:
1. Build and run the C versions of the program for x86_64. Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop
2. Review, build, and run Then modify the x86_64 assembler programs. Make sure you understand message so that it includes the code.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 {{Admon/tip|Character conversion|In order to print the loop index value, you will need to convert from an integer to digit character. Build and run In ASCII/ISO-8859-1/Unicode UTF-8, the digit characters are in the C versions of range 48-57 (0x30-0x39). You will also need to assemble the program message to be printed for aarch64. Verify that 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 disassemble perform a sequence of writes for the object code in thee parts of the message ('Loop: ', number, '\n'). You may want to refer to the ELF binary using manpage for <code>objdump -dascii</code>.}}
5. Review{{Admon/tip|6502 Implementation|For reference, build, and run the aarch64 assembler programs. Make sure you understand the codehere is a [[6502 Counting Loop Example|6502 implementation of this loop]].}}
63. Here Repeat the previous step for x86_64. For reference, here is a basic the loop code in x86_64 assembler - this loops from 0 to 9, using r15 as the index (loop control) counter:
.text
.globl _start
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 $startmin,%r15 /* loop index */
loop:
/* '''... body of the loop ... do something useful here ... ''' */
inc %r15 /* increment index */
syscall
4. Extend this code, combining it with the AArch64 code to loop from the "Hello World" example00-30, so that it prints printing each value as a 2-digit from 0 to 9 like this:decimal number.
Loop: 0 Loop: 1 Loop: {{Admon/tip|2 Loop: 3 Loop: 4 Loop: 5 Loop: 6 Loop: 7 Loop: 8 Loop: 9-Digit Conversion|You will need to take the loop index and convert it to a 2-digit decimal number by dividing by 10. Read the description of the division instruction carefully. On x86_64, you need to set up specific registers before performing a division. On AArch64, you will need to use a second instruction to find the remainder after a division.}}
{{Admon/tip|Character conversion|In order to print 5. Change the loop index value, you will need to convert from an integer code as needed to digit character. In ASCII/ISO-9959-1/Unicode UTF-8, suppress the digit characters are in the range 48-57 leading zero (0x30printing 0-0x39). You will also need to assemble the message to be printed for each line 30 instead of 00- 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 thee parts of the message ('Loop: ', number, '\n'30).}}
75. Repeat step 6 for aarch64. 8. Extend the 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.}} 9. Repeat step 8 previous two steps for aarch64x86_64.
=== Deliverables ===
1. Complete the group lab section, above.
2. Extend Blog about the programs you've written. Describe the experience of writing and debugging in assembler programs (both , as compared to writing in other languages. Contrast x86_64 and aarch64) to suppress the high digit when it is 0. In other wordsassembler, your experience with each, the printed values should progress from 0-30 instead and your opinions of from 00-30each. It is OK Include links to output a space in place the source code for each of the suppressed digit (this will cause the numbers to be aligned vertically in the printout)your assembler programs.
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 == Challenge ===144"). Add a spacer between each table, and use a function/subroutine to format the numbers with leading-zero suppression.
OptionalThe output could look something like this:
Write a program to print the times tables from 1x 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 (1x1 through 12x12).= 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