SPO600 Lab5 64-Bit Assembly Language Lab Pt.1 ---AArch64 part


In this Lab, I am going to experiment with assembler on the x86_64 and aarch64 platforms.

Task 1 Observe the difference between source code and the object file of the aarch64 assembly language 

source file:
object file:


Task 2 -- A loop which print 6 "Loop" word

 I have to modify a provided code block in the aarch64 system to print loop for 6 times. 

modified code:

.text
.globl _start
min = 0                          /* starting value for the loop index; **note that this is a symbol (constant)**, not a variable */
max = 6                         /* 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 ... */
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, msg     /* message location (memory address) */
     mov     x2, len     /* message length (bytes) */
     mov     x8, 64       /* write is syscall #64 */
     svc     0            /* invoke syscall */
     add     x19, x19, 1     /* increment the loop counter */
     cmp     x19, max        /* see if we've hit the max */
     b.ne    loop            /* if not, then continue the loop */
     mov     x0, 0           /* set exit status to 0 */
     mov     x8, 93          /* exit is syscall #93 */
     svc     0               /* invoke syscall */
.data
msg:   .ascii      "Loop\n"
len=   . - msg
The yellow highlighted code : print the String "Loop"
 
result:


Task 3. Modify the code so that it also show the iteration number, i,e, Loop: 1, Loop: 2..etc


I would like to add an extra num variable to .data. Update the variable in every loop and print it.

code:
.text
.globl _start
min = 0                          /* starting value for the loop index; **note that this is a symbol (constant)**, not a variable */
max = 6                         /* loop exits when the index hits this number (loop condition is i<max) */
start:
     mov     x19, min     
     adr    x21, num
loop:

     /* ... body of the loop ... do something useful here ... */
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, msg    /* message location (memory address) */
     mov     x2, len1           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */

        /* print the number*/
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, num    /* message location (memory address) */
     mov     x2, len2           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */

     add     w19, w19, 1     /* increment the loop counter */

     /* update the num value in .data*/
     mov    w20, w19
     add    w20, w20, 48
     strb   w20, [x21]

     cmp     x19, max        /* see if we've hit the max */
     b.ne    loop            /* if not, then continue the loop */
     mov     x0, 0           /* set exit status to 0 */
     mov     x8, 93          /* exit is syscall #93 */
     svc     0               /* invoke syscall */
.data
msg:    .ascii      "Loop: "
len1=   . - msg
num:     .ascii     "0 \n"
len2=   . - num
Yellow highlighted: the variable added to print the iteration number
Red highlighted: to change the num variable in .data
Green highlighted: to print the num variable in .data

result:

Task 4. Extend the code to loop from 00 to 32

I have two way to code. The first way is to do find the units digit and tens digits by division in every loop. But, it is quite boring and I tend to prevent performing division. As a result, I decide to use another way, which is use the registers to store each digit's ascii value to be display.

.text
.globl _start
min = 0                          /* starting value for the loop index; **note that this is a symbol (constant)**, not a variable */
max = 33                         /* loop exits when the index hits this number (loop condition is i<max) */
_start:
     mov     x19, min
     adr     x22, num      //address of first digit
     add     x23, x22, 1   //address of second digit
     mov     w21, 48       //the ten digit
     mov     w20, 48
loop:

     /* ... body of the loop ... do something useful here ... */
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, msg    /* message location (memory address) */
     mov     x2, len1           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */

        /* print the number*/
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, num    /* message location (memory address) */
     mov     x2, len2           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */


     add     x19, x19, 1     /* increment the loop counter */
     add     w20, w20, 1     /* increment the units digit*/

     cmp     w20, 58
     b.lt    update

     /*update the  tens digit when units digit >10*/
     add     w21, w21, 1
     strb    w21, [x22]
     mov     w20, 48
 /* update the num value in .data*/
update:
     strb    w20, [x23]

     cmp     x19, max        /* see if we've hit the max */
     b.ne    loop            /* if not, then continue the loop */
     mov     x0, 0           /* set exit status to 0 */
     mov     x8, 93          /* exit is syscall #93 */
     svc     0               /* invoke syscall */
.data
msg:    .ascii      "Loop: "
len1=   . - msg
num:     .ascii     "00\n"
len2=   . - num

Yellow highlighted:  Initialize the register to store the address of output and the counter
Red highlighted: check if the units digit>10, then check the tens digits accordingly
Green highlighted: update num variable which is going to be printed

result:

Task 5. modify the code to make it suppress the leading zero

My plan is to use a register to store the memory address to be edited during the iteration and increment it instead. Then, when the loop first reach 10, it change the memory address to the digit after. 

code:
.text
.globl _start
min = 0                          /* starting value for the loop index; **note that this is a symbol (constant)**, not a variable */
max = 33                         /* loop exits when the index hits this number (loop condition is i<max) */
_start:
     mov     x19, min
     adr     x22, num      //address of first digit
     adr     x23, num      //address  which increment during the loop
     mov     w21, 48       //the ten digit
     mov     w20, 48
loop:

     /* ... body of the loop ... do something useful here ... */
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, msg    /* message location (memory address) */
     mov     x2, len1           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */

        /* print the number*/
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, num    /* message location (memory address) */
     mov     x2, len2           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */


     add     x19, x19, 1     /* increment the loop counter */
     add     w20, w20, 1     /* increment the units digit*/


     cmp     x19, 10
     b.ne    checkten
     /*the first time reach 10*/
     add     x23, x22, 1
     mov     w20, 58
     mov     w21, 48
checkten:
     cmp     w20, 58
     b.lt    update
     /*update the  tens digit when units digit >10*/
     add     w21, w21, 1
     strb    w21, [x22]
     mov     w20, 48
 /* update the num value in .data*/
update:
     strb    w20, [x23]

     cmp     x19, max        /* see if we've hit the max */
     b.ne    loop            /* if not, then continue the loop */
     mov     x0, 0           /* set exit status to 0 */
     mov     x8, 93          /* exit is syscall #93 */
     svc     0               /* invoke syscall */
.data
msg:    .ascii      "Loop: "
len1=   . - msg
num:     .ascii     "0 \n"
len2=   . - num
 Yellow highlighted:  how the units digit changing
Red highlighted: check if the loop reach 10 the first time. If so, the incrementing digit will be changed. Also, move the current value in the digital to the new digit before the regular calculation with carry.

result:

Task 6. Modify the code so that it output in hexadecimal (0-20) instead of decimal (0-32)

This is easy. I just have to change the value to be compare before the branches and add an extra part to increase the ascii value stored in the register to "A"(65) whenever it reach 58 .

code:
.text
.globl _start
min = 0                          /* starting value for the loop index; **note that this is a symbol (constant)**, not a variable */
max = 33                         /* loop exits when the index hits this number (loop condition is i<max) */
_start:
     mov     x19, min
     adr     x22, num      //address of first digit
     adr     x23, num      //address  which increment during the loop
     mov     w21, 48       //the ten digit
     mov     w20, 48
loop:

     /* ... body of the loop ... do something useful here ... */
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, msg    /* message location (memory address) */
     mov     x2, len1           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */

        /* print the number*/
     mov     x0, 1           /* file descriptor: 1 is stdout */
     adr     x1, num    /* message location (memory address) */
     mov     x2, len2           /* message length (bytes) */
     mov     x8, 64             /* write is syscall #64 */
     svc     0                  /* invoke syscall */


     add     x19, x19, 1     /* increment the loop counter */
     add     w20, w20, 1     /* increment the units digit*/

     cmp     w20, 58
     b.ne    chknewdg
     add     w20, w20, 7

chknewdg:
     cmp     x19, 16
     b.ne    check16
     /*the first time reach 16*/
     add     x23, x22, 1
     mov     w20, 71
     mov     w21, 48
check16:
     cmp     w20, 71
     b.lt    update
     /*update the  digit when units digit >16*/
     add     w21, w21, 1
     strb    w21, [x22]
     mov     w20, 48
 /* update the num value in .data*/
update:
     strb    w20, [x23]

     cmp     x19, max        /* see if we've hit the max */
     b.ne    loop            /* if not, then continue the loop */
     mov     x0, 0           /* set exit status to 0 */
     mov     x8, 93          /* exit is syscall #93 */
     svc     0               /* invoke syscall */
.data
msg:    .ascii      "Loop: "
len1=   . - msg
num:     .ascii     "0 \n"
len2=   . - num

Yellow highlighted:  check if the digit reach 10. If so, increase it to "A"
Red highlighted: criteria changed from 10 to 16

result:

 


Comments

Post a Comment

Popular posts from this blog

SPO600 Project Stage 1 (Pt.1) - Create a GCC Pass

Image
Create a GCC Pass I would like to create a GCC Pass. I expect the pass will be used to analyze the GIMPLE files. Step 1. Get to the gcc subdirectory I go to the directory of my gcc source code. Then, I get to the gcc subdirectory inside the sourcecode of gcc. Step 2. Create a very simple pass I create a Pass file modeled on the pass_nrv. I just hope the pass works first. So, the pass is as simple as possible. code: /* Test Pass Jeff Yau, Seneca Polytechnic College Modelled on tree-nrv.cc and tree-ctyler.cc by Chris Tyler, Seneca Polytechnic College, 2024-11 This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Se...
Read more

SPO600 Project Stage 2 (Pt.1) - GCC pass locating clone function

Image
In project stage 1, I created a GCC pass in both x86-64 server and AARCH64 server to print the functions' name and counting number of block. Now, I would like to revise the pass again and increase it's functionality. Step 1. Modify the pass First, I would like to detect if the function is a clone. When a clone is detected, loop will be broken. Meanwhile, just ignore the count of statement and blocks first. They will be useful for later part. revised code: /* Test Pass Jeff Yau, Seneca Polytechnic College Student ID :142466234 Modelled on tree-nrv.cc and tree-ctyler.cc by Chris Tyler, Seneca Polytechnic College, 2024-11 This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even th...
Read more

SPO600 Project Stage 2 (Pt.2) - GCC pass locating clone function -modified version

Image
In project stage 1, I created a GCC pass in both x86-64 server and AARCH64 server to print the functions' name and counting number of block. In stage 2 pt.1, I was trying to modify the code to locate the clone but in vain. I sought advice from my professor, Chris Tyler and note that for the default version of the clone, the node->name() function will return function name without any .variant, i.e. without .default . That's why the previous version does not work. As a result, I revised the code accordingly and it works now. revised code: /* Test Pass Jeff Yau, Seneca Polytechnic College Student ID :142466234 Modelled on tree-nrv.cc and tree-ctyler.cc by Chris Tyler, Seneca Polytechnic College, 2024-11 This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is dis...
Read more