[[Category:SPO600-futureLabs]][[Category:Assembly Language]]{{Admon/lab|Purpose of this Lab|In this lab, you will experiment with assembler on the x86_64 and aarch64 platforms.}}{{Chris Tyler DraftAdmon/tip|SPO600 Servers|Perform this lab on [[SPO600 Servers]] (you may use your own systems if they are of the right architecture and appropriately configured).}}

{{Admon/note|Purpose of this == Lab|In this lab, you will experiment with assembler on the x86_64 and aarch64 platforms.}}{{Admon/tip|Ireland|Perform this lab on ireland.proximity.on.ca.)}}4 ==

== Lab 3 = Code Examples ===

=== Ireland The code examples for this lab are available in the file <code>/public/spo600- Configuration ===assembler-lab-examples.tgz</code> on each of the [[SPO600 Servers]].

The host ''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-gas.s # ... gas syntax │   ├── hello-nasm.s # ... nasm syntax │   └── Makefile └── c # Portable C versions ├── hello2.c # ... using write(ireland) ├── hello3.proximityc # .on.ca. using syscall() 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]] ├── hello.c # ...using printf() └── Makefile

The directory <code>~/arm64/spo600/examples<code>Throughout this lab, which is also accessible as <code>~/spo600-examples</code>, contains these files:take advantage of ''[[make and Makefiles|make]]'' whenever possible. === 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]] === Optional Investigation ===

── hello ├── assembler # 'hello world' example programs │ ├── aarch64 # aarch64 assembler version │ │ ├── hello1.s │ │ └── Makefile │ └── x86_64 # x86_64 assembler Build and run the three C versions │ ├── hello-gas.s # 64-bit instructions of the program for assembley with the gnu assembler (called 'gas'x86_64 and aarch64, using <code>make</usr/bin/as) │ ├── hello-nasmcode>.s # 32-bit instructions for assembley with Take a look at the nasm assembler (/usr/bin/nasm) │ └── Makefile └── c ├── hello2.c # C version using differences in the write() syscall wrapper ├── hellocode.c # C version using printf() └── Makefile

Throughout this lab, 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 advantage a look at the code. Also notice the total amount of ''[[make and Makefiles|make]]'' whenever possiblecode.

14. Build and run the C versions assembly language version of the program for x86_64aarch64 using <code>make</code>, taking note of the commands that are executed to assemble and link the code. Use objdump to Verify that you can disassemble and review the [[Machine Language|machine object code]] in the binaries ELF binary using <code>objdump - make sure you understand it. Save d ''objectfile''</code> and take a look at the binaries for later reviewcode.

4. Build and run <!-- {{Admon/tip|Answers in the Video!|The answers to the C versions of first three steps below are contained in the program for aarch64 (noteassociated [https: you may need to <code>make clean</code/web.microsoftstream.com/video/8c3c1353-5729-4217-b1ba-371410f14ad4 lecture video.]}} -->).

51. Review, build, and run the aarch64 assembler assembly language programs. Take a look at the code using <code. Use >objdump -d '''objectfile'''</code> and compare it to disassemble and review the machine source code in the binaries, and make sure you understand it.

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

.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 ) */

mov $0x19,%r15 /* loop index */min

inc %r15 /* increment register 15 '''... body of the loop ... do something useful here ...''' */ cmpq $10add x19, x19,%r15 /* see if we're done */1 jne cmp x19, max b.ne loop /* loop if we're not */

movq $mov x0, 0,%rdi /* exit status -> 0 */ movq $60mov x8,%rax 93 /* exit is syscall sys_exit #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

Extend this code, combining it with code from Then modify the "Hello World" example, message so that it prints includes the loop index values, showing each digit from 0 to 9 like this:

{{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-99598859-1/Unicode UTF-8, the digit characters are in the range 48-57 (0x30-0x39). You will also need to assemble the message that is output on to be printed for each line - you can do this by writing the digit into the message buffer before writing outputting itto stdout, which is probably the best approach, or you can perform a sequence of writes for the various portions thee parts of the message('Loop: ', number, '\n'). You may want to refer to the manpage for <code>ascii</code>.}} {{Admon/tip|6502 Implementation|For reference, here is a [[6502 Counting Loop Example|6502 implementation of this loop]].}} 3. Repeat the previous step 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 4. 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. 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.}} 5. Change the code as needed to suppress the leading zero (printing 0-30 instead of 00-30). 5. Repeat the previous two steps for x86_64. === Deliverables === 1. Complete the lab section, above. 2. 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 each 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