Project stage 1 navigate GCC codebase

Continues from the previous build GCC, this involves navigating the GCC codebase to understand and modify specific components such as compilation passes, argument parsing, and producing dumps during compilation passes.

1. Compilation passes:
The code for compilation passes is in the gcc/passes.c file. Compilation passes are managed using the pass_data structure.

To add a new pass, we will create a new file gcc/my_pass.c:
#include "gcc-plugin.h"
#include "tree-pass.h"

static unsigned int my_pass_execute(void) {
    return 0;
}

struct opt_pass my_pass = {
    .type = GIMPLE_PASS,
    .name = "my_pass",
    .gate = NULL,
    .execute = my_pass_execute,
};

int plugin_init(struct plugin_name_args *plugin_info,
                struct plugin_gcc_version *version) {
    return 0;
}

To test the new pass we will add the pass to the pass manager in gcc/passes.c and recompile GCC.


2. Argument Parsing
Argument parsing is managed in the gcc/opts.c file. Arguments are defined in gcc/common.opt

Adding a dummy argument to gcc/common.opt:
dummy-arg
Common Report Var(flag_dummy_arg) Init(0)

Handling the arugment in code:
if (flag_dummy_arg) {
    printf("Dummy argument is set\n");
}

3. Producing dumps during compilation passes
dumps are produced using the dump_* functions in gcc/tree-dump.c

Pass to produce a dump:
static unsigned int my_pass_execute(void) {
    dump_printf_loc(dump_file, "My pass is running\n");
    return 0;
}
Then recompile GCC and run it with the -fdump-tree-all option to produce dumps.

While working on this project, I have learned the GCC build process and the structure of its codebase, how GCC manages compilation passes, arugument parsing, and dump production. 
The most interesting part was understanding how different components of the compiler interact and how changes in one part can affect the overall compilation process. 
The most challenging part was navigating the complex codebase, it required a deep dive into the documentation and experimenting with different approaches to achieve the desired outcomes. 
I identified my gaps in my knowledge are cross compilation and optimizing build times, I plan to adress through further study and more practice. 
I found myself most attracted to tasks involving writing and debugging code. 

Comments

Post a Comment

Popular posts from this blog

Project stage 3 Integrate, Tidy, & Wrap

 The project code's location in class git repository should be under  https://github.com/Seneca-CDOT/gcc/tree/2024-S-tests/gcc/testsuite/g%2B%2B.target/aarch64  with folder name afmv, but its still waiting for review required approve.   It is located in my branch waiting for the merge:  https://github.com/zijunlii/gcc/tree/master/gcc/testsuite/g%2B%2B.target/aarch64/afmv The directory structure is as follows: gcc/testsuite/g++.target/aarch64/  └── afmv/         ├── afmv_test_1.c         ├── afmv_test_1. exp          ├── afmv_test_2.c         ├── afmv_test_2. exp          ├── afmv_test_3.c         ├── afmv_test_3. exp          └── Makefile The AFMV capability correctly creates and executes multiple versions of functions. Only basic functionality is verified. More complex functions ...
Read more

Project stage 1 GCC build

This is the project stage 1, we will become familiar with the GCC build process on AArch86 and x86 platforms.  1. Clone the GCC repository from the official source git clone git://gcc.gnu.org/git/gcc.git cd gcc For AArch86 2. Creating build directory and configure GCC for AArch64 mkdir build-aarch64 cd build-aarch64 ../configure --target=aarch64-linux-gnu --prefix=$HOME/gcc-aarch64 --disable-multilib 3. Starting the build process and install GCC  make -j$(nproc) make install For x86 2. Creating build directory and configure GCC for x86 mkdir build-x86 cd build-x86 ../configure --prefix=$HOME/gcc-x86 --disable-multilib 3. Starting the build process and install GCC make -j$(nproc) make install While working on this project I leanred the build process and the necessary configurations for different architectures. The challenges was dealing with build dependenicies and managing long build times.
Read more

lab 1 mob programming

In this lab our focus was on the 6502 Emulator, a tool that simulates the classic 6502 microprocessor. The task involved filling a bitmapped display with different colors and optimizing the performance of the code. This blog post will outline our experiments, performance calculations, code modifications, and personal reflections on the process. Initial Code:  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  ...
Read more