Project Stage 2: Introduction

Building a Custom GCC Pass for Function Clone Analysis

I'm thrilled to provide my strategies for working on Project Stage 2, which is about developing a customized GCC compiler pass. Due to the complexity of this endeavour, I will be writing many posts to chronicle my progress.

Project Overview
We're creating a unique GCC pass for Stage 2 that will:

  • Determine which functions were copied during compilation.
  • Examine these replicated routines to find any duplication.
  • Output messages showing which clones need to be pruned in the GCC dump
Why This Matters
This work is groundbreaking in the field of automated function multi-versioning (AFMV). By explicitly identifying and removing superfluous function clones, our approach will be the first to increase code efficiency and decrease binary size.

Technical Approach
Analyzing function clones while disregarding surface-level variations like variable names is the main problem. We must create a technique for creating signatures that ignores implementation specifics that have no bearing on functionality and instead captures the fundamental structure and behaviour of functions.

Implementation Plan
I'll be approaching this project in phases:
  1. Setting up the foundation: Creating a boilerplate GCC pass and integrating it into the compiler source tree
  2. Identifying cloned functions: Detecting functions that follow the "function.variant" naming pattern and locating their resolver functions
  3. Comparison methodology: Developing a system to generate comparable signatures for functions or directly comparing their structure
  4. Cross-architecture testing: Ensuring our pass works correctly on both AArch64 and x86 architectures

Initially, we'll simplify our approach by assuming each program contains only one cloned function with two versions.

Attribution
The project requirements come from Professor Chris Tyler. For more details, check out his wiki at spo600.cdot.systems.
 http://spo600.cdot.systems/doku.php?id=spo600:2025_winter_project#project_stage_2clone-pruning_analysis_pass

Comments

Post a Comment

Popular posts from this blog

Project Stage 3: Enhancing GCC Pass for Multiple Function Clone Handling: Progress Update

In my earlier work, I developed a basic GCC pass for identifying and comparing function clones. For this latest phase, I focused on improving the pass to handle programs containing multiple cloned functions. Additionally, I wanted to enhance code organization by consolidating data storage, replacing multiple parallel vectors and maps with a structured approach using a dedicated struct to store characteristics of clone variants. Implementation Process Phase 1: Code Revision for Multi-Function Support I modified the pass to properly handle programs with multiple cloned functions in x86 server environments. The updated code includes all critical support files. The revised implementation's core is a specialized pass that processes GIMPLE representation data. This pass systematically identifies resolver functions and creates appropriate tracking structures for each function being cloned. The implementation uses maps and vectors to store function characteristics, including basic block co...
Read more

Project Stage 1: Troubleshooting a bit - Coming soon

  Procedure for Troubleshooting Debugging using the following method: First Error Analysis: I carefully reviewed the error logs after my initial build attempt failed. Copy ./pass-instances.def:47:23: error: expected ';' at end of member declaration 47 | NEXT_PASS_WITH_ARG (pass_mypass, 1, 1) This suggested an issue with my pass registration syntax. Examining Pass Declaration Conventions: I ran the following to examine the passes that were already included in the GCC source code: Copy cd ~/git/gcc/gcc grep -r "NEXT_PASS" passes.def This showed that NEXT_PASS (pass_name, number) was the proper format instead of NEXT_PASS_WITH_ARG. Function name Pattern Analysis: I looked at various pass implementations to learn more about the name conventions: Copy cd ~/git/gcc/gcc find . -name "tree-*.cc" | xargs grep "make_pass_" This demonstrated to me that the pattern make_pass_X, where X is the pass name without the "pass_" prefix, is what GCC ...
Read more

Lab - 1: Exploring 6502 Assembly

Image
Exploring 6502 Assembly: A Journey into Low-Level Programming  Introduction Assembly language has always been both fascinating and challenging for programmers. Unlike high-level languages where abstractions make coding easier, assembly requires a deep understanding of how the CPU processes instructions. In this lab, we explore the basics of 6502 Assembly Language through bitmap displays, code modifications, performance enhancements, and using the 6502 Emulator. This experience is the first step towards learning more complex architectures such as x86_64 and AArch64.
Read more