Lab 4 in class portion

This lab was very difficult for me, as the progress of this class feels very fast and if I'm not up to date I feel pretty left behind in the material and I wasn't of much help during this in class portion. My group mates completed a good portion of the code during the lab without much input from me. I took some time to review and study the material for the aarch 64 and x86 64 assemblers and when I took on this lab again I felt much more prepared and ready to do it. Below is my completed portion of the in class section of the assignment. 


.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     x19, min

loop:


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


    mov     x3, x19        /*store value from x19 temporarily in x3*/

    add     x3, x3, 48    /* x3 has ascii for character */


    adr     x4, msg     /* message location (memory address) */

    strb    w3, [x4, 6]


    mov     x0, 1           /* file descriptor: 1 is stdout */


/* ascii for zero is 48 */


    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


Once I got the hang of it the code was much easier to understand. The code has a two main constant symbols being min and max with values 0 and 10 respectively to handle the looping. mov x19, min initializes the loop counter to the min value, then enters the loop. mov x3, 19 will copy the value of the loop counter into x3 so that it can be altered without changing the actual loop counter. It then adds the ASCII value for 0 (48) into x3  to convert the integer to ASCII. The code then loads the address of the string into the register x4 and then stores the ASCII value of the loop index into w3 which is in Loop: \n. Then the program calls to write the message and then it will increment and compare the current value with the max value. 


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

Comments

Post a Comment

Popular posts from this blog

Early stages of project

 I initially set up and built the current version of GCC on the aarch64-3 server that is provided. I started the build and it took at least an hour to fully compile. I limited the enabled languages to strictly C and C++ as I am most comfortable in these languages and to reduce the complexity of the project. The two files that control compilation passes are passes.cc, and tree-pass.h /* Description of GIMPLE pass.  */ class gimple_opt_pass : public opt_pass { protected:   gimple_opt_pass (const pass_data& data, gcc::context *ctxt)     : opt_pass (data, ctxt)   {   } }; /* Description of RTL pass.  */ class rtl_opt_pass : public opt_pass { protected:   rtl_opt_pass (const pass_data& data, gcc::context *ctxt)     : opt_pass (data, ctxt)   {   } } I did some reading and research on gimple passes and learned that they help optimize code and makes transformation at a high level before going to lower representations.
Read more

Building GCC again on aarch64-002

 Unfortunately the server I used to build gcc originally was aarch64-003 but that was shut down so I have to go through the process again on 002. The build time on the aarch64-002 server took 1 hour and 55 minutes approximately, I initially used time in my build command but I accidentally missed the information so I had to use stat build.log and find the duration of the build time by subtracting the final modification from the birth of the build.log file. Access: 2024-11-29 14:20:41.788188929 -0500 Modify: 2024-11-29 13:53:09.328736193 -0500 Change: 2024-11-29 13:53:09.328736193 -0500  Birth: 2024-11-29 11:57:40.960613010 -0500
Read more

Project Stage 2: Testing

Image
 To test my custom pass I first extracted the spo600-test-clone files into my gcc-test-001 directory and simply compiled and ran the program with -fdump-tree-ctyler. I ran it on the vol1.c file, the contents of vol1.c are as following: [dpark39@aarch64-002 test-clone]$ cat vol1.c // vol1.c - fixed-point volume scaling algorithm // Chris Tyler 2017.11.29-2021.11.16 - Licensed under GPLv3. // For the Seneca College SPO600 Course #include <stdlib.h> #include <stdio.h> #include <stdint.h> #include <stdbool.h> #include "vol.h" int16_t scale_sample(int16_t sample, int volume) {         return ((((int32_t) sample) * ((int32_t) (32767 * volume / 100) <<1) ) >> 16); } int main() {         int             x;         int             ttl=0; // ---- Create in[] and out[] arrays         int16_t*    ...
Read more