Changes

Jump to: navigation, search

SPO600 64-bit Assembly Language Lab

3,214 bytes added, 09:30, 13 September 2019
References
[[Category:SPO600 Labs]][[Category:Assembly Language]]
 
{{Admon/caution|Not Updated|This page contains outdated information. It will be updated with new information for Fall 2014.}}
{{Admon/lab|Purpose of this Lab|In this lab, you will experiment with assembler on the x86_64 and aarch64 platforms.}}
{{Admon/tip|IrelandSPO600 Servers|Perform this lab on ireland.proximity.on.ca[[SPO600 Servers]] (you may use your own x86_64 system if desired, along with the AArch64 server).}}
== Lab 3 ==
<!--
 
### 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 ===
Throughout this lab, take advantage of ''[[make and Makefiles|make]]'' whenever possible.
 
-->
=== Code Examples ===
 
The code examples for this lab are available in the file /public/spo600-assembler-lab-examples.tgz on both [[SPO600 Servers|Aarchie 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 # write() version
|-- hello3.c # syscall() wrapper version
|-- hello.c # printf() version
`-- Makefile
 
Throughout this lab, take advantage of ''[[make and Makefiles|make]]'' whenever possible.
 
=== Resources ===
* [[Assembler Basics]]
* [[Syscalls]]
* [[x86_64 Register and Instruction Quick Start]]
* [[aarch64 Register and Instruction Quick Start]]
=== Group Lab Tasks ===
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, 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 run take a look at the x86_64 assembler programscode. Make sure you understand Notice the total amount of code.
43. Build Review, build, and run the C versions of x86_64 assembly language programs. Take a look at the program for aarch64 (note: you may need to code using <code>make cleanobjdump -d '''objectfile'''</code>)and compare it to the source code. Verify that you can disassemble Notice the object absence of other code in (compared to the ELF C binary using <, which had a lot of extra code>objdump -d</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. 5. Review, build, and run the aarch64 assembler assembly language programs. Make sure you understand 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 x86_64 assembler - this loops from 0 to 9, using r15 as the index (loop control) counter:
.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) */
loop:
/* '''... body of the loop ... do something useful here ... ''' */
inc %r15 /* increment index */
syscall
Extend this This codedoesn't actually do anything while looping, combining because the body of the loop is empty. Combine it with code from the "Hello World" 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: 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-99598859-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 aarch64.
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 printoutoutput).
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.
=== References Optional Challenge ===* [[Assembler Basics]]** [[x86_64 Register 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 Instruction Quick Start]]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** [[aarch64 Register and Instruction Quick Start]] 10 x 12 = 120 11 x 12 = 132 12 x 12 = 144

Navigation menu