Project Stage 2: Clone-Pruning Analysis Pass

 

Project Stage 2

Goal

In Stage 2 of my project, the goal was to create a pass for the GCC compiler that would analyze the program and identify cloned functions. It would then compare these cloned functions to check if they are very similar, and decide whether they should be removed (pruned) or kept. The decision would be shown in the GCC diagnostic dump as either "PRUNE" or "NOPRUNE."

Step 1: Creating the Dummy Pass

I started by creating a simple dummy pass that would only output basic messages. This was to make sure everything was working properly before I added more complex logic.

Step 2: Iterating Through the Program Code

Once the dummy pass was working, I moved on to the next step. This involved writing logic to go through the functions in the program being compiled. GCC uses an intermediate representation called GIMPLE, and I used this to read through and prepare the functions for the next steps.

Step 3: Identifying Cloned Functions

In this step, I added the logic to find cloned functions. For simplicity, I assumed there was only one cloned function in the program, with two versions of it. This helped keep things manageable.

Step 4: Comparing the GIMPLE Representations

Next, I needed to compare the GIMPLE representations of the cloned functions to see if they were the same or different. This is where I faced a lot of difficulty. I spent several hours trying to compare the functions but ran into errors. The issue was that even small differences, like temporary variable names or labels, were making it hard to tell if the functions were truly the same. I tried a few different methods, but I couldn’t fix the issues in time.

Step 5: Deciding to Prune or Not

Once I could compare the functions properly, I planned to have the pass output "PRUNE" if the functions were the same or "NOPRUNE" if they were different. But since I couldn’t solve the comparison problems, I couldn’t complete this step.

Step 6: Positioning the Pass in the GCC Pipeline

It was also important to make sure that the pass ran late in the compilation process, after optimizations like vectorization. This would ensure that the program was fully optimized before my analysis started. But again, I couldn’t test this due to the errors.

Errors Encountered

I faced several issues that stopped me from moving forward:

  1. Compilation Errors: I had problems integrating the pass with the rest of the GCC code. This was probably due to misconfigurations or conflicts with other parts of GCC.

  2. GIMPLE Comparison Issues: The biggest challenge was comparing the GIMPLE representations of the cloned functions. Even small differences, like different temporary variable names, caused errors, and I couldn’t figure out how to handle them in time.

Because of these issues, I couldn’t finish the pass or fully test whether the functions should be pruned or not. This made it hard to progress further.

Conclusion and Next Steps

Even though I couldn’t complete this stage, I learned a lot about the process of creating a GCC pass. Moving forward, I plan to:

  1. Fix the problems with comparing GIMPLE representations and figure out how to ignore small differences.
  2. Make sure the pass works properly in the GCC build process, on both x86_64 and AArch64 systems.
  3. Test everything once the issues are fixed to ensure the pass works as expected.

This stage was challenging, but it gave me valuable experience in understanding how compilers work. I’m looking forward to resolving the issues and continuing with the project.

Comments

Post a Comment

Popular posts from this blog

Project Stage 1- GCC Build & Dump on AArch64

Image
  Goal  The primary objective of my project is to develop a working proof-of-concept prototype for the function-pruning component of Automatic Function Multi-Versioning (AFMV) within the GNU Compiler Collection (GCC) specifically designed for AArch64 systems. This initiative aims to build upon existing functionalities and enhance the efficiency of the compiler. A significant aspect of this project is to familiarize myself with the process of building GCC on AArch64 architecture. By engaging in this project on the aarch64-002 server, I hope to gain hands-on experience and become comfortable with the intricacies involved in the build process. Understanding the steps required to successfully compile and configure GCC on this platform will provide me with invaluable insights into compiler development and operation. I have followed the project instructions outlined in SPO600 2024 Fall Project to guide my work. Steps to Build GCC 1.  Clone the GCC Repository:  Firstly, I...
Read more

SPO600 LAB 1

Image
6502 Assembly Language Lab Hello! My name is Harleen Singh, and this post is about my experiments with 6502 assembly language as part of the SPO600 course.  Bitmap Code The first task was to run the following code to fill the display with yellow using the 6502 processor: Here is the code which was given to us in Lab 1 instructions. lda #$00 ; set a pointer in memory location $40 to point to $0200 sta $40 ; ... low byte ($00) goes in address $40 lda #$02 sta $41 ; ... high byte ($02) goes into address $41 lda #$07 ; colour number ldy #$00 ; set index to 0 loop: sta ($40),y ; set pixel colour at the address (pointer)+Y iny ; increment index bne loop ; continue until done the page (256 pixels) inc $41 ; increment the page ldx $41 ; get the current page number cpx #$06 ; compare with 6 bne loop ; continue until done all pages Calculating Performance To calculate the execution time for my code running on a 1 MHz clock, I broke it down into two parts: the inn...
Read more

Project Stage 3: Tidy & Wrap

Introduction In this stage, I aimed to address the feedback provided by the professor and resolve the errors encountered in the previous stages of the GCC pass project. However, despite my efforts, I have faced significant challenges that have hindered my progress. Process and Steps Taken Building and Testing the Demo Pass - I started by building and testing the provided demo pass to understand its functionality. - However, I encountered several issues during this process, which are detailed below. Modifying the Pass 1. Adding Diagnostic Dumps :    - I attempted to modify the pass to include diagnostic dumps to demonstrate its execution.    - Example code snippet:      ```cpp      if (dump_file)        {          fprintf (dump_file, "===== Dummy Pass Diagnostic Dump =====\n");        }      ``` 2. Iterating Through Code Being Compiled :    - I updat...
Read more