SPO600 2025 Winter Project - Stage 3: Plan (Part1)

 As part of the final stage of the SPO600 project, I will be extending and polishing my custom GCC pass (skim) to support analyzing multiple clone groups and provide accurate [PRUNE] and [NO PRUNE] recommendations. Below is a structured plan for how I intend to proceed with Stage III, in line with the official requirements and challenges outlined by professor.


Objectives

  1. Support multiple clone groups

    • Remove the assumption that only one base+clone pair exists.

    • Detect and compare multiple function clone groups independently.

  2. Build realistic test cases

    • Write at least two FMV-cloned functions per test case (e.g. scale_samples, sum_data).

    • Design one function to produce a [PRUNE] and another to produce a [NO PRUNE] result.

  3. Ensure cross-architecture compatibility

    • Validate pass functionality on both x86_64 and aarch64.

    • Confirm that PRUNE/NOPRUNE logic works across target-specific clones.

  4. Improve diagnostics

    • Add BB count and statement count diff messages to aid debugging.

    • Log detailed clone comparisons per function group.

  5. Finalize cleanup and usability

    • Keep my implementation style, avoiding major structure rewrites.

    • Fix any logic gaps that led to silent failures in Stage II.



Test Plan

  • Create a test with two functions:

    1. A simple sum_data() to encourage pruning.

    2. A complex scale_samples() to avoid pruning.

  • Use __attribute__((target_clones(...))) to generate FMV variants.

  • Compile with custom-built GCC and inspect .skim dumps for correct classification.



Goal

By the end of Stage III, my pass should be able to:

  • Analyze multiple clone groups.

  • Output detailed logs in .skim files.

  • Provide both [PRUNE] and [NO PRUNE] results within the same compilation.

  • Be usable by others through shared Makefile and test sources.

This wraps up the technical plan. Implementation and testing will follow in the next blog update.






Comments

Post a Comment

Popular posts from this blog

SPO600 2025 Winter Project - Stage 1: Create a Basic GCC Pass (part1)

Image
 Project Overview The goal of this project is to extend the GCC compiler by adding a custom pass that can analyze the functions being compiled. A GCC pass is a stage in the compilation process that processes intermediate representations (IR) of the source code. These passes perform various optimizations and analyses before generating the final machine code. 📌 What Will This Custom Pass Do? In Stage 1 , I am implementing a GCC pass that: • Iterates through each function in the compiled code. • Prints the function name being analyzed. • Counts the number of basic blocks in the function. • Counts the number of GIMPLE statements inside each function. • Outputs this information to the console. By completing this stage, I will gain hands-on experience with GCC’s internal structures, intermediate representations like GIMPLE , and how to modify GCC’s compilation pipeline. Step 1: Setting Up the Environment 🔹 Note: I have already completed GCC setup ...
Read more

SPO600 2025 Winter Project - Stage 2: GIMPLE Level Clone Analysis and Pruning (part4)

Image
 Progress Summary In this post, I worked on developing a custom GIMPLE-level GCC pass named skim to analyze function clone groups produced by Function Multi-Versioning (FMV). The goal was to determine whether the clones are functionally equivalent at the GIMPLE IR level and output either PRUNE or NOPRUNE . So far, I’ve successfully implemented the initial infrastructure and logic: - Iterated through all functions using `FOR_EACH_FUNCTION` - Classified functions into clone groups using regex to detect `.default`, `.resolver`, and `.variant.*` suffixes - Successfully grouped clones and output the groups to `dump_file` - Verified `.skim` file generation using the `-fdump-tree-skim` compiler flag - Confirmed correct execution of the `pass_skim::execute()` function Now, I aim to extend the functionality to compare GIMPLE IR within clone groups to verify if clones are truly functionally equivalent. Goal Determine at GIMPLE level if functions within each clone group are equivalent, an...
Read more

Lab 1 - 6502 Assembly Language

Image
Introduction In this post, I'll share my experience working on a fun and challenging lab about 6502 assembly language. Assembly language is a low-level programming language, and in this lab, I explored how it works by writing code to manipulate a simple pixel display. My goal was to learn how to calculate performance, optimize code, and modify it to create interesting visual effects on the display. Bitmap Code This code:     - Starts at memory address $0200 (the beginning of the display)     - Loops through all 1536 pixels (6 pages of 256 pixels each)     - Sets each pixel to yellow ($07) 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...
Read more