LAB 04 - SERVER 1

"How I Built GCC From Source: A Step-by-Step Guide"

"The GNU Compiler Collection (GCC) is a powerful tool for compiling source code into executable programs. As a developer, it's essential to understand how compilers work. In this blog post, I'll walk you through my experience of building GCC from scratch, challenges I faced, and tips to optimize the process"

 x86-001

Step 1: Configure the Build Process

""""./contrib/download_prerequisites

mkdir build

cd build

../configure --enable-languages=c,c++ --disable-multilib""""

STEP 2:  Build GCC using make:

make -j$(nproc)



STEP 3: Prove that it’s different from the system compiler

Comparison of System GCC (11.3.1) vs Custom-Built GCC on x86 Server:

When comparing the system's default GCC (version 11.3.1) to the custom-built development GCC, there are several key differences worth noting.

  1. System GCC is stable and reliable, with optimizations that are tailored for broad compatibility and production use. However, it lacks the latest features and optimizations available in the development version of GCC.

  2. The development GCC I built offers more advanced features, potentially better performance, and optimizations that are tailored for newer C/C++ standards and modern hardware. However, it is still under development and might contain experimental bugs or instability, especially for legacy software.

  3. While the system GCC offers reliability, the development GCC shines in its potential for improved performance, especially when compiling newer code or leveraging the latest compiler features.


SYSTEM==>

NEW GCC==>


STEP 4: CALCULATE TIME

INITIAL BUILD

Calculation:

Start Time: ~08:49 (when the build began) End Time: 09:20 (when xgcc was created)

Duration: ~31 minutes


REBUILT





STEP 5: SUCCESSFULL C PROGRAM



STEP 6: UPDATE TIMESTAMP ON PASSES.CC



TIME:


NULL BUILD:


REFLECTION==>

This lab was a valuable hands-on experience in understanding how to build and install a compiler from source code, which is essential for many development and research tasks. Through this lab, I gained insight into the complexities involved in managing different versions of the GCC compiler and the various trade-offs between stability and cutting-edge features in software development.

1. Building from Source:
The process of building GCC from source on both the x86 and aarch64 servers was both challenging and enlightening. I followed the instructions carefully to install and build the development version of GCC. Initially, I faced a few difficulties, such as resolving dependencies and understanding the various configuration options, but with the help of resources like the GCC internals manual, I managed to complete the build
2. Build Time Insights:
I also learned about how make handles builds and rebuilds, and how the time required for a rebuild can be drastically reduced compared to the initial full build. This experience emphasized the importance of efficient build systems when working with large software projects.
3. Overall, this lab taught me the value of understanding the tools I use in development and how version control (even at the level of GCC versions) can impact the results of compiling and building software. Although the development GCC can be exciting with new features, I realize that for most of my day-to-day work, the stability of the system GCC would be my go-to choice, unless I'm working on a project that explicitly requires the newer features and optimizations offered by the development version.




Comments

Post a Comment

Popular posts from this blog

Project Stage 1: Create a GCC pass

Image
  🎬SPO600 2025 Winter Project - Project Stage 1: Create a Basic GCC Pass SUMMARY: A GCC pass is a step in the compilation process that processes intermediate representations (IR) of the source code, performing various optimizations and analyses before generating the final machine code. The objective of this project is to extend the GCC compiler by adding a custom pass that can analyze the functions being compiled. 一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一 💣How Is This Custom Pass Going to Work?  Iterates through all of the compiled code's functions. Outputs the name of the function under analysis. Determines how many fundamental blocks there are in the function. Determines how many GIMPLE statements are there in each function. 一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一 ⭐STEP 1 =================>  VEFIRFYING DETAILS💬 Lab 04 ✅ GCC source and build directories were correctly set up✅ Command to verify : ls  -l ~✅ 一一一一一一一一一一一一一一一一一一一一一一一一一一...
Read more

LAB 03

Image
6502 Assembly Programming Lab: Creating a Simple Number Guessing Game Introduction In this lab, I had the opportunity to dive into 6502 assembly programming by creating a simple program that meets a set of criteria for outputting both on the character screen and the graphics screen, accepting user input, and utilizing arithmetic operations. The task was part of a larger effort to explore the 6502 microprocessor, with the goal of building the skills needed for more complex x86_64 and AArch64 assembly language programming. Requirements The lab had the following main requirements: The program must work in the 6502 Emulator. It must output to both the character (text) screen and the graphics (bitmapped) screen. It must accept user input from the keyboard. It must incorporate arithmetic/math instructions (e.g., adding, subtracting, bitwise operations, etc.). Plan I planned the following structure for the Number Guessing Game : Generate a random number : Use the 6502's random byte genera...
Read more

Project Stage 2: Part 2( The End)

Image
In this part of the project, I will be analyzing the cloned functions to demonstrate how the Clone-Prune Analysis Pass works in practice. Specifically, I’ll take a closer look at the scale_samples functions from the clone-test-prune and clone-test-noprune test files, which were provided for testing and not created by me. The goal here is to show how the pass successfully identifies substantially identical cloned functions (for pruning) and highlights differences that should prevent pruning. Clone-Prune Test Files Comparison: Let’s start by reviewing the clone-test-prune files. These contain the functions scale_samples.default , scale_samples.Mrng , and scale_samples.resolver . Our goal is to compare scale_samples.default and scale_samples.Mrng , which should be identical and therefore should be pruned. scale_samples.default: scale_samples.Mrng: As you can see, scale_samples.default and scale_samples.Mrng are nearly identical, except for their memory addresses (as highlighte...
Read more