Building GCC

In my last blog, I talked about contributing to the GCC compiler by helping out with the Automatic Function Multi-versioning (AFMV) for aarch64. In order to do that I must first learn how to build GCC myself.

Unfortunately, since I do not have an aarch64 machine, I have to rely on the aarch64 systems my professor has setup in order to build/work with GCC. The system I decided to start my GGC build is an ARMv8 machine with 4 cores and 16 GiB ram.

Now to start, the first step we must do is to clone the GCC git repository. Following the steps from my class wiki page I cloned the repo to my spo600 directory using the following command.

$ git clone git://gcc.gnu.org/git/gcc.git ~/spo600/

After cloning, the next step is to create a build directory and configure our build to use that directory. Here are the commands I used to do so.

$ mkdir ~/spo600/gcc-build-001
$ cd ~/spo600/gcc-build-001
$ ~/spo600/gcc/configure --prefix=$HOME/spo600/gcc-build-001

Now we can start the build process. One thing to note is that GCC takes a really long time to build, so I will be using the time command to record how long my build takes just for the metrics, as well as record the logs just in case. To build GCC, I ran the following command inside my gcc-build-001 directory.

$ time make -j 5 |& tee build.log

I used make -j 5 to tell make to run 5 jobs in parallel. Our class wiki page states that it is recommended to use a range between (num cores + 1) to (num cores * 2 + 1) as the number of jobs to run. Since this system has 4 cores, I decided to use the lower end of this range, i.e. 5, just to be safe because this is a shared server.

On this server, builds take around 84 minutes. For my case, my build took around 77 minutes which was nice.

Now that we have compiled the source code, we can install it. I run the following command to install gcc to the directory I specified earlier with --prefix.

$ make install

To use the newly built gcc instead of the system gcc, we have to make sure that our $PATH searches for binaries in our build directory first before the system bins.

# In .bashrc in home directory
PATH=$HOME/spo600/gcc-build-001/bin:$PATH
export PATH

Then reload our config by running source .bashrcin the home directory.

Now when I run which gcc, I see that it is found in our build directory

$ which gcc
~/spo600/gcc-build-001/bin/gcc

Running gcc --version also now shows us that we are using an experimental version.

$ gcc --version
gcc (GCC) 15.0.0 20241024 (experimental)
Copyright (C) 2024 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

We now have successfully built the gcc compiler ourselves.

Now, where do I even begin making changes? This codebase is huge! Stay tuned for my next blog once I figure that out :,)

And as always, thanks for reading :)

Comments

Post a Comment

Popular posts from this blog

Lab 03 - Breakout Game

Image
This lab is quite special compared to previous ones, as it is more subjective and taps into our creativity. We were tasked with creating any program we want, as long as it meets these criteria: The program must work in the 6502 Emulator It must output to the character screen as well as the graphics (bitmapped) screen. It must accept user input from the keyboard in some form. It must use some arithmetic/math instructions (to add, subtract, do bitwise operations, or rotate/shift) Some suggestions given by our professor were to make either a simple game or a simple calculator/converter. With that in mind, I decided to remake the 1976 arcade game Breakout. What is Breakout? Based on its Wikipedia description , Breakout is a 1967 arcade game developed and published by Atari, Inc. It involves some bricks, a paddle, and a bouncing ball. The goal is to destroy all bricks with a bouncing ball, using the paddle as a sort of tool to keep the ball in play. You lose when the ...
Read more

Lab 04 - Diving into 64-bit Assembly

Image
After having worked with 6502 Assembly, we now move on to the more complex 64-bit Assembly that is being used by the majority of computers today. In this lab we explore the 64-bit assembly language used in both aarch64 (ARM) and x86_64 (Intel/AMD) architectures. We will explore their differences, similarities, as well as the tradeoffs for using either. The task for this lab was to develop a simple program that prints the following output: Loop: 0 Loop: 1 Loop: 2 Loop: 3 Loop: 4 Loop: 5 Loop: 6 Loop: 7 Loop: 8 Loop: 9 Loop: 10 Loop: 11 Loop: 12 Loop: 13 Loop: 14 Loop: 15 Loop: 16 Loop: 17 Loop: 18 Loop: 19 Loop: 20 Loop: 21 Loop: 22 Loop: 23 Loop: 24 Loop: 25 Loop: 26 Loop: 27 Loop: 28 Loop: 29 Here is program I developed to do this in Aarch64 assembly. .text .globl _start min = 0 max = 30 _start: mov x19, min // Store to x19 the value of min (0) loop: /* ... body of the loop ... do something useful here ... */ // write() syscall takes 3 args; file descr...
Read more