Project Stage 2 (Part 2): Set Up GCC for My Clone-Pruning Pass

A Journey Into GCC

When I started this project, I knew it was going to be a challenge. The GCC compiler is a massive and complex system, and diving into its internals felt daunting. My task was to build GCC from source, integrate a custom pass to analyze function clones, and test everything on the SPO600 AArch64 server.


Setting Up the Environment

1. Cloning the Source Code The first step was to clone the GCC source code into my home directory. Thankfully, the repository was straightforward to access:

git clone git://gcc.gnu.org/git/gcc.git ~/gcc-src

Once the clone was complete, I checked for the configure script in ~/gcc-src, which confirmed that the source was ready for building.


2. Preparing the Build I created separate directories to keep everything organized: one for building GCC and another for installing it locally:

mkdir ~/gcc-build ~/gcc-install

3. Adding the Demo Pass To save time, I copied and extracted the demo files provided in /public/spo600-gcc-pass-demo.tgz into the GCC source directory:

cp /public/spo600-gcc-pass-demo.tgz ~/gcc-src/
cd ~/gcc-src
tar -xvf spo600-gcc-pass-demo.tgz

These files added a basic pass to the GCC pipeline as a starting point, saving me from building one completely from scratch.


4. Configuring and Building GCC Configuring GCC was straightforward. I ran:

cd ~/gcc-build
../gcc-src/configure --disable-bootstrap --enable-languages=c,c++ --prefix=$HOME/gcc-install

This configured GCC to build only the C and C++ frontends and install locally in ~/gcc-install.

The actual build process took quite a while:

make -j$(nproc)

It took just over an hour on the server, but using tmux saved me from having to restart if my connection dropped.


5. Installing GCC Once the build completed, I installed GCC:

make install

The new GCC was installed in ~/gcc-install, and I verified it worked:

~/gcc-install/bin/gcc --version

Challenges

1. Connection Interruptions One of the most frustrating parts of this stage was losing my connection to the server during the build process. I had to restart the build twice before realizing I could use tmux to keep the process running in the background.

2. Slow Build Times Although the server was reasonably fast, building GCC still took over an hour. This was manageable but taught me the importance of rebuilding only the parts that change after making modifications.


Reflections

This stage was a great introduction to GCC’s structure and build process. By the end of it, I felt more confident navigating GCC’s source code and modifying it. Seeing the custom pass integrated into the build gave me a real sense of accomplishment.

Next, I would dive into implementing the clone-pruning logic, which I knew would be the real challenge.


Nhận xét

Đăng nhận xét

Bài đăng phổ biến từ blog này

Project Stage 2 (Part 3): Implementing the Clone-Pruning Logic

Building the Heart of the Pass Once I had GCC built and the demo pass working, it was time to dive into the real challenge: implementing the clone-pruning logic in tree-ctyler.cc . How I Tackled It 1. Understanding Gimple IR GCC represents programs using intermediate representations, and my pass needed to analyze the Gimple IR. At first, Gimple seemed overwhelming, but once I found examples of basic block and statement iteration, it started making sense. 2. Comparing Functions The goal was to check if two cloned functions were equivalent. I wrote a function to compare Gimple statements: That I added the following logic to tree-ctyler.cc: bool compare_gimple_statements (gimple *stmt1, gimple *stmt2) { if ( gimple_code (stmt1) != gimple_code (stmt2)) return false ; // Different types of statements return true ; } Then, I added a loop to iterate through the basic blocks and statements of two functions: bool are_functions_equivalent (tree f1, tree f2) { basic_b...
Đọc thêm

SPO600 - Lab 3: 6502 Program Lab: Inches to Feet Converter

Hình ảnh
 In this lab, I used the 6502 assembly language to build a simple inches-to-foot converter. This project allowed me to experiment with arithmetic operations, keyboard input handling, and direct screen output without relying on ROM routines. This hands-on experience also helped me prepare for more advanced assembly languages like x86_64 and AArch64. Resources During the lab, I used a variety of resources, including: 6502 documentation provides detailed information about the 6502 architecture and instruction set. 6502 Emulator: For testing and debugging code. 6502 Math and Procedures: A reference book for arithmetic operations and control flow. Sample code demonstrates graphical output and keyboard input handling. Project Concept My project is a simple calculator that converts a specified number of inches to feet. In this program, the user enters an inch number, and when they press Enter, the program calculates and displays the corresponding number of feet. This simple conversion nec...
Đọc thêm