Lab 04 - GCC Build Lab

-

If you've ever written a C or C++ program, chances are you've used GCC (GNU Compiler Collection) to compile your code. But have you ever wondered how GCC itself is built?

In this lab, I took on the challenge of building the latest GCC from source on two different systems:

  • x86-001 (Intel/AMD CPU - x86_64 architecture)
  • aarch64-002 (ARM64 CPU - typically used in mobile devices & some servers)

This was an exciting hands-on experience that taught me:
✓ How large software projects are compiled from source
✓  How different CPU architectures affect build performance

✓  How incremental builds and optimizations can save time

Why Build GCC from Source?

1. The system’s default compiler is usually outdated. By building GCC from source, you get the newest optimizations and features.
2. Customization: You can enable or disable specific components, optimize for performance, or experiment with compiler modifications.
3. Multi-Platform Development: If you're working on different CPU architectures, like ARM vs. Intel, building from source ensures compatibility.
4. Hands-on Learning: This is a great way to understand how compilers work and improve your system programming skills.

Step 1: Obtain the Source Code

         a. Create a directory to store the GCC source code


               

          b. Clone the GCC Repository

                                           



Step 2: Configure the Build

           a. Create a Build Directory



    
           b. Configure GCC Without Overwriting the Existing Version






Step 3: Perform the Build

                     

Step 4: Install the Build

               a. Install the Compiled GCC


                b. Verify the Installation

aarch64-002:




x86-001:





Step 5: Test the Build

                a. Create a C test file

aarch64-002:


 

 x86-001:

     
           b. Compile the file

aarch64-002:


x86-001:

Step 6: Update File Timestamp


aarch64-002:

x86-001:

Reflection

This lab was a great hands-on experience in building and installing GCC from source. It helped me understand how large software projects are compiled and the steps involved in setting up a custom build. I worked on two different server architectures: x86-001 (Intel/AMD) and aarch64-002 (ARM64), which gave me insight into how different CPUs impact performance.

One of the biggest takeaways was how important parallel builds are for speeding up the process. Using make -j 24 made a huge difference in reducing build time. I also learned how to use the time command to measure build performance and understand how much CPU time was actually used versus real elapsed time.

A challenge I faced was a failed build that forced me to start over. After troubleshooting, I realized that clearing out the build directory and starting fresh (rm -rf) was sometimes the best solution. This showed me the importance of debugging, patience, and systematic problem-solving in software development.

Another interesting part was testing the newly installed compiler by compiling a simple C program. It was satisfying to see that the custom-built GCC worked correctly. Updating file timestamps and observing the impact on rebuild times also gave me a better understanding of incremental builds and how developers optimize compilation.

Overall, this lab helped me see the bigger picture of how compilers work and why building software from source can be useful. It also reinforced key skills like troubleshooting, using make, and analyzing build performance, all of which are valuable in software development.




Comments

Post a Comment

Popular posts from this blog

Project Stage 1

-
Image
 Introduction This project focuses on creating a custom pass for the GCC compiler, which will analyze functions during compilation. The pass will iterate through functions in the compiled code, print their names, count the number of basic blocks, and count the number of GIMPLE statements. Step 1: Creating the GCC Pass Creating the Pass File I navigated to the gcc/ directory inside the GCC source tree and created a new file: [ ayoung54@aarch64-002 ~]$ cd ~/git/gcc/gcc [ayoung54@aarch64-002 gcc]$ nano a_pass.cc Implementing the Pass I added the following code to define my custom GCC pass in a_pass.cc: #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   ...
Read more

Lab05 - x86_64

-
Image
Objective:   In this lab, I worked with 64-bit assembly language on x86_64 platform to learn about CPU architecture and assembly instructions. Getting Started with Code Example   The first step is to retrieve the code example from the server. The file is compressed, so we'll extract it into the desired location (in my case, the home directory): cd ~ tar xvf /public/spo600-assembler-lab-examples.tgz Once extracted, you’ll see a folder named  spo600 , which contains all the necessary files. x86_64: Investigating the C Code To explore the C version of the program, navigate to the folder containing the  hello.c  file and compile it using  make : make x86_64:  Disassemble the binary to view the assembly code: objdump -d hello x86_64: This will show us the assembly instructions, where we can observe that different CPU architectures (x86_64 vs Aarch64) generate different instructions, even for the same program. Exploring the x86_64 Platform Now, let’s dive in...
Read more

Lab 03 - 6502 Program Lab (Revised)

-
Worm Game In this lab, I coded a game that would work within the 6520 Emulator while meeting specific criteria, including output to both the character and graphic screens, accepting keyboard input, and utilizing mathematical operations like addition and subtraction.  While building a classic worm game in Assembly, I ran into a few tricky errors that took some time to figure out. I want to share those mistakes and how I fixed them so you can avoid the same headaches.  On one particularly long night of coding, I decided to take on the challenge of re-building a classic Worm game! This game would be simple yet engaging, utilizing both the character screen and graphic screen for a fun experience. I found that  Specification The game starts with a worm moving across the screen, which is controlled using the keyboard. The worm body grows every time it "eats" a fruit, which is randomly placed on the screen. The user can control the worm's movement by pressing the W , A , S , or ...
Read more