Lab 4 - GCC Build Lab

In this lab, we're learning how to build large software projects using tools like Make and Automake/Autotools. I'll be working on two servers, x86-001 and aarch64-002.

Task:

On both servers, I'll download, build, and install the latest development version of the GCC compiler.

Below are the steps to complete the lab!

1. Clone the GCC repository using the below command

    git clone git://gcc.gnu.org/git/gcc.git

2. Configure the build
     create a separate build directory to avoid building GCC in the source directory

     mkdir ~/gcc-build-001
 
     cd gcc-build-001

3. To set up GCC to be installed in a specific location (e.g., gcc-test-001), Run the configure    script with the preferred prefix for the installation path

    ~/gcc/gcc/configure --prefix=$HOME/gcc-test-001



4. Build the source code using the below command

    time make -j 24 |& tee build.log

    The -j option in make specifies the maximum number of jobs that can run simultaneously.
    The |& operator is shorthand for 2>&1 |, which redirects both standard output and standard         error and pipes them into the tee command. The tee command then saves this output to a        specified file.

    Record the build time for the aarch64 server:


   Record the build time for the x86 server:
   


    Explanation of Time Outputs:
    - real: The actual elapsed time from start to finish
    - user: The total CPU time spent executing in user mode
    - sys: The CPU time spent executing in system mode

5. Install the build

    command:
    make install


    x86 server






    arch server



6. Test the build

    commands:

    export PATH=$HOME/gcc-test-001/bin:$PATH
    gcc --version
    make check

7. Verify the installation by checking the GCC version. 

        command:
    
        gcc --version

        x86 server

        arch server



  • Check the built GCC version:
    ~/gcc-test-001/bin/gcc --version

    8. Build a C program

    To verify that the newly built GCC can compile a simple C program:

    1. Create a test C program:
      nano test.c

    2. Add the following simple C code:



      Compile the program using the built GCC:

      ~/gcc-test-001/bin/gcc test.c -o test

      Run the compiled program:

      ./test



      If it prints Hello, GCC!, then your compiler works correctly.


      9. Update the timestamp on the file "passes.cc"
      Method 1: Using touch command

      commands:
      cd ~/gcc/gcc
      touch passes.cc

      Method 2: Editing and saving the file manually

      commands:
      nano passes.cc

      10. Rebuild the software after updating passes.cc


      11. Perform a "Null Rebuild"

      Run make again without modifying any files:

      time make -j 24 |& tee null_rebuild.log




      Reflections:

      This lab was a great hands-on experience in building software from source, especially something as complex as GCC. The initial build took a long time, but it was satisfying to see it complete successfully. Testing the new compiler and comparing it with the system's GCC helped me understand the importance of version control in development environments. The incremental and null rebuilds showed how make optimizes compilation by only recompiling necessary files. I also learned to use logging and time to track performance, which is useful for debugging and benchmarking. Overall, it was a challenging but rewarding process that deepened my understanding of software compilation.

Comments

Post a Comment

Popular posts from this blog

Lab 2 - Lab Results

Introduction In this blog post, I will share my experience working on a lab where we animated a small 5x5 graphic to move diagonally across the screen and bounce off the edges. The lab required an understanding of low-level memory manipulation, conditional logic, and efficient screen rendering. I'll walk you through the code, the changes made to implement bouncing logic, and my reflections on the learning process. **Since we collaborated as a group on optimizing the code, my work may resemble that of my teammates =================================================================== Initial Code The following code moves a 5×5 graphic diagonally across the screen: ; ; draw-image-subroutine.6502 ; ; This is a routine that can place an arbitrary ; rectangular image on to the screen at given ; coordinates. ; ; Chris Tyler 2024-09-17 ; Licensed under GPLv2+ ; ; ; The subroutine is below starting at the ; label "DRAW:" ; ; Test code for our subroutine ; Moves an image diagon...
Read more

Project Stage 1

Image
In this project, I set out to create a custom GCC pass that analyzed GIMPLE files by iterating through every function, counting the basic blocks, and tallying the number of GIMPLE statements. I successfully integrated this pass into the GCC build system and tested it on a simple C program. Here’s how I did it. 1. Writing the Pass Code I began by writing the pass code in C++ and saved it in a file named tree-my-new-pass.cc within the gcc subdirectory of my GCC source. My pass, which I named "my_new_pass", was designed to run during the GIMPLE phase. The code looked like this: #include "config.h" #include "system.h" #include "coretypes.h" #include "backend.h" #include "tree-pass.h" #include "pass_manager.h" #include "context.h" #include "diagnostic-core.h" #include "tree.h" #include "tree-core.h" #include "basic-block.h" #include "gimple.h" #include "gimp...
Read more

Lab 5 - Part 1 - Aarch 64

Image
In this lab, my goal is to dive into assembly programming on both the x86_64 and AArch64 platforms. For Task 1, 1. I will closely examine how the AArch64 assembly source code—written in a human-readable format—is transformed into an object file containing machine code. This investigation will help me understand the assembly process by highlighting the differences between the high-level source instructions and the low-level binary output generated by the assembler. Source file Object file 2 : Constructing a Loop That Prints “Loop” Six Times In this task, I need to adapt the assembly code on the aarch64 server so that it outputs the word “Loop” exactly six times. Starting with the provided code, I will introduce a counter in one of the general-purpose registers, initialize it to zero, and increment it after each print. Once the counter reaches six, the loop will terminate. This requires adjusting the assembly instructions to compare the loop counter against a maximum value, calling the a...
Read more