Lab 4: GCC Build from Source

We're learning to use programs like Make and Automake/Autotools to create huge software projects in this lab. x86-001 and aarch64-002 are the two servers I'll be working on.

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.

    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

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

   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 time stamp on the file "passes.cc"
    Method 1: Usingthe  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:

    Building software from source, especially something as complicated as GCC, was a terrific hands-on experience in this lab. Although the first build took a while, it was rewarding to see it finished successfully. The significance of version control in development environments became clearer to me after testing the new compiler and contrasting it with the system's GCC. The incremental and null rebuilds demonstrated how to optimize compilation by recompiling only the files that are required. To measure performance for troubleshooting and benchmarking, I also learned to utilize time and logging. Overall, it was a difficult but worthwhile exercise that helped me better understand software compilation.

Comments

Post a Comment

Popular posts from this blog

Project Stage 3: Enhancing GCC Pass for Multiple Function Clone Handling: Progress Update

In my earlier work, I developed a basic GCC pass for identifying and comparing function clones. For this latest phase, I focused on improving the pass to handle programs containing multiple cloned functions. Additionally, I wanted to enhance code organization by consolidating data storage, replacing multiple parallel vectors and maps with a structured approach using a dedicated struct to store characteristics of clone variants. Implementation Process Phase 1: Code Revision for Multi-Function Support I modified the pass to properly handle programs with multiple cloned functions in x86 server environments. The updated code includes all critical support files. The revised implementation's core is a specialized pass that processes GIMPLE representation data. This pass systematically identifies resolver functions and creates appropriate tracking structures for each function being cloned. The implementation uses maps and vectors to store function characteristics, including basic block co...
Read more

Project Stage 1: Troubleshooting a bit - Coming soon

  Procedure for Troubleshooting Debugging using the following method: First Error Analysis: I carefully reviewed the error logs after my initial build attempt failed. Copy ./pass-instances.def:47:23: error: expected ';' at end of member declaration 47 | NEXT_PASS_WITH_ARG (pass_mypass, 1, 1) This suggested an issue with my pass registration syntax. Examining Pass Declaration Conventions: I ran the following to examine the passes that were already included in the GCC source code: Copy cd ~/git/gcc/gcc grep -r "NEXT_PASS" passes.def This showed that NEXT_PASS (pass_name, number) was the proper format instead of NEXT_PASS_WITH_ARG. Function name Pattern Analysis: I looked at various pass implementations to learn more about the name conventions: Copy cd ~/git/gcc/gcc find . -name "tree-*.cc" | xargs grep "make_pass_" This demonstrated to me that the pattern make_pass_X, where X is the pass name without the "pass_" prefix, is what GCC ...
Read more

Lab - 1: Exploring 6502 Assembly

Image
Exploring 6502 Assembly: A Journey into Low-Level Programming  Introduction Assembly language has always been both fascinating and challenging for programmers. Unlike high-level languages where abstractions make coding easier, assembly requires a deep understanding of how the CPU processes instructions. In this lab, we explore the basics of 6502 Assembly Language through bitmap displays, code modifications, performance enhancements, and using the 6502 Emulator. This experience is the first step towards learning more complex architectures such as x86_64 and AArch64.
Read more