DEV Community: drflamemontgomery

I Built a GCC Plugin for Struct Inheritance

drflamemontgomery — Thu, 09 Apr 2026 03:50:56 +0000

If you have entered the world of programming, there is a fair chance that you have heard of C or learned C. As a language, C is very robust and simple language but it is lagging behind the newer languages that have more features and buttons. Which is why I took it upon myself to begin a journey of adding more features via GCC Plugins.

Boilerplate

To begin with, we need a c file to contain all our plugin code. So we will begin with the basic plugin boilerplate.

// plugin.c
#include "gcc-plugin.h"
#include "plugin-version.h"

#include "diagnostic.h"

// This is required for GCC to accept the plugin
int plugin_is_GPL_compatible;

// This is where we will register the plugin hooks  
int plugin_init(struct plugin_name_args *plugin_info,
                struct plugin_gcc_version *version) {
  // It's good practice to check for a compatible gcc version
  if (!plugin_default_version_check(version, &gcc_version)) {
    return 1;
  }

  // A little message so that we know the plugin loads
  warning(UNKNOWN_LOCATION, "Hello from %s", plugin_info->base_name);

  return 0;
}

With our plugin.c boilerplate, it's time to create a Makefile so that we can compile our plugin

# Makefile
HOST_GCC=g++
TARGET_GCC=gcc
PLUGIN_SOURCE_FILES= plugin.c

# Get the GCC plugin directory for referencing later
GCCPLUGINS_DIR:= $(shell $(TARGET_GCC) -print-file-name=plugin)
CXXFLAGS+= -I$(GCCPLUGINS_DIR)/include -fPIC -fno-rtti -O2

default: embedstruct.so

embedstruct.so: $(PLUGIN_SOURCE_FILES)
    $(HOST_GCC) -shared $(CXXFLAGS) $^ -o $@

.PHONY: clean
clean:
    rm -f embedstruct.so

We can now build our project but it's useless to build it without a test program.

// test.c
#include <stdio.h>

int main(void) {
  printf("Hello World!\n");
  return 0;
}

Now to add an extra Makefile rule to build the test program.

# Makefile
...

test: embedstruct.so
    $(TARGET_GCC) -fplugin=./embedstruct.so test.c -o test

...

clean:
    rm -f embedstruct.so
    rm -f test

Initial Test

Now that we have our boilerplate out of the way, we can test to see if our plugin compiles and loads correctly

$ make
g++ -shared -I/usr/local/lib/gcc/x86_64-pc-linux-gnu/16.0.0/plugin/include -fPIC -fno-rtti -O2 plugin.c -o embedstruct.so
$ make test
gcc -fplugin=./embedstruct.so test.c -o test
cc1: warning: Hello from embedstruct
$ ./test
Hello World!

Success! Our code compiles and runs correctly.

Adding the Attributes

Now that our foundation is out of the way and working, we can start by adding our attribute so that GCC doesn't throw an error every time we try to use it.

Step 1

int plugin_init(...) {
  ...

  register_callback(
    plugin_info->base_name, // Name of our plugin
    PLUGIN_ATTRIBUTES, // The callback to hook into
    register_attributes, // Our callback we will create
    NULL // We don't have any user data
  );

  ...
}

Step 2

Define an attribute_spec for our attribute

static struct attribute_spec embed_struct_attr = {
  "embed_struct", // Name of attribute used in C code
  0, // minimum of 0 arguments
  0, // maximum of 0 arguments
  true, // This attribute only applies to declarations 
  false, // doesn't apply to type
  false, // doesn't apply to function types
  false, // doesn't affect type identity
  handle_embed_struct_attr, // callback to attribute processing
  NULL, // we don't have any exclusions
};

Step 3

Add boilerplate attribute handling callback

static tree handle_embed_struct_attr(tree *node, tree name, tree args,
                                     int flags, bool *no_add_attrs) {
  // Shockingly, most of the code that we write
  // will not be in this block
  warning(UNKNOWN_LOCATION, "attribute 'embed_struct' not implemented");
  return NULL_TREE;
}

Step 4

static void register_attributes(void *event_data, void *data) {
  // Tell GCC that we have a custom attribute
  register_attribute(&embed_struct_attr);
}

Step 5

Add tree.h to the list of headers

Testing

Let's modify our test.c code so that we use our custom attribute

#include <stdio.h>

// Parent struct type
struct s1 {
  int field1;
  int field2;
};

// Child struct type
struct s2 {
  // Our parent type with the embed_struct attribute
  [[gnu::embed_struct]]
  struct s1 super;

  int field3;
};

int main(void) {
  struct s2 test;
  test.super.field1 = 0;
  test.super.field2 = 1;
  test.field3 = 2;

  printf("super.field1: %d\n", test.super.field1);
  printf("super.field2: %d\n", test.super.field2);
  printf("field3: %d\n", test.field3);

  return 0;
}

Now to compare before and after registering the attribute

# Before
$ make test
gcc -fplugin=./embedstruct.so test.c -o test
cc1: warning: Hello from embedstruct
test.c:13:10: warning: 'gnu::embed_struct' scoped attribute directive ignored [-Wattributes]
   13 |   struct s1 super;
      |          ^~
$ ./test
super.field1: 0
super.field2: 1
field3: 2

# After
$ make test
gcc -fplugin=./embedstruct.so test.c -o test
cc1: warning: Hello from embedstruct
test.c:13:10: warning: attribute 'embed_struct' not implemented
   13 |   struct s1 super;
      |          ^~
$ ./test
super.field1: 0
super.field2: 1
field3: 2

The difference isn't much, however the warning we get after registering is the warning that WE decided to create because we haven't finished the attribute

Finish Type Pass

To implement our new type, we need to do 4 steps.

Step 1

Hook into the FINISH_TYPE callback. This will allow us to change the type structure.

int plugin_init(...) {
  ...

  register_callback(
    plugin_info->base_name, // Name of our plugin
    PLUGIN_FINISH_TYPE, // The callback to hook into
    finish_type, // Our callback we will create
    NULL // We don't have any user data
  );

  ...
}

Step 2

Check each field for the embedstruct attribute

static void finish_type(void *event_data, void *data) {
  // Get the current type data
  tree type = (tree)event_data;

  // We don't like segmentation faults so we will check
  // for NULL pointers
  if (!type)
    return;

  // We only want this to work inside of `struct` types
  if (TREE_CODE(type) != RECORD_TYPE)
    return;

  // Get the list of every struct field
  tree *prev = &TYPE_FIELDS(type);

  while (*prev) {
    tree field = *prev;

    // If this isn't a declared struct field then we don't
    // want to test it
    if (TREE_CODE(field) != FIELD_DECL) {
      prev = &DECL_CHAIN(field);
      continue;
    }

    // Check if our attribute is attached
    if (lookup_attribute("embed_struct", DECL_ATTRIBUTES(field))) {
      // TODO add anonymous structure at same location
    }

    prev = &DECL_CHAIN(field);
  }
}

Step 3

Add an anonymous struct of the same type and the same location. Easiest way to do this is to copy the existing field without it's declared name and add it to the field list

static tree copy_field_anonymous(tree field, tree context) {
  // Create a declaration node
  tree new_field = build_decl(DECL_SOURCE_LOCATION(field), FIELD_DECL,
                              NULL_TREE, TREE_TYPE(field));

  // Copy the field data
  DECL_FIELD_BIT_OFFSET(new_field) = DECL_FIELD_BIT_OFFSET(field);
  DECL_ALIGN_RAW(new_field) = DECL_ALIGN_RAW(field);

  SET_DECL_OFFSET_ALIGN(new_field, DECL_OFFSET_ALIGN(field));
  DECL_NOT_FLEXARRAY(new_field) = DECL_NOT_FLEXARRAY(field);
  DECL_FIELD_OFFSET(new_field) = DECL_FIELD_OFFSET(field);

  DECL_SIZE(new_field) = DECL_SIZE(field);
  DECL_SIZE_UNIT(new_field) = DECL_SIZE_UNIT(field);

  // Point to the same attributes for same effects
  DECL_ATTRIBUTES(new_field) = DECL_ATTRIBUTES(field);

  // Add this to the correct context (sort of similar to a parent)
  DECL_CONTEXT(new_field) = context;

  // Remove this from any list so we can move it wherever we want
  DECL_CHAIN(new_field) = NULL_TREE;

  // Let the compiler know that this was a computed declaration
  DECL_ARTIFICIAL(new_field) = 1;

  return new_field;
}


static void finish_type(void *event_data, void *data) {
  ...
    if (lookup_attribute("embed_struct", DECL_ATTRIBUTES(field))) {
      // Copy the field as an anonymous struct in the same context
      tree anon_field = copy_field_anonymous(field, DECL_CONTEXT(field));

      // Add anonymous field to the list
      DECL_CHAIN(anon_field) = DECL_CHAIN(field);
      DECL_CHAIN(field) = anon_field;

      prev = &DECL_CHAIN(anon_field);

      // TODO remove attribute
      continue;
    }
  ...
}

Step 4

While technically unnecessary, I still prefer to remove the attributes after processing.

static void remove_attribute(tree node, const char *attribute) {
  // Iterate over attribute list
  for (tree *attr_ptr = &DECL_ATTRIBUTES(node); *attr_ptr;) {
    if (is_attribute_p(attribute, get_attribute_name(*attr_ptr))) {
      // Remove attribute
      *attr_ptr = TREE_CHAIN(*attr_ptr);
    } else {
      // Check next attribute
      attr_ptr = &TREE_CHAIN(*attr_ptr);
    }
  }
}

static void finish_type(void *event_data, void *data) {
  ...
      prev = &DECL_CHAIN(anon_field);
      // ~~We only need to remove from one of them because~~
      // ~~their attributes are linked~~
      remove_attribute(anon_field, "embed_struct");

      // Edit: I discovered that they weren't linked so we
      //       are removing both
      remove_attribute(field, "embed_struct");

      continue;
  ...
}

Step 5

Remove the unnecessary warnings

~~warning(UNKNOWN_LOCATION, "attribute 'embed_struct' not implemented");~~
~~warning(UNKNOWN_LOCATION, "Hello from %s", plugin_info->base_name);~~

Final Test

Now that we have finished our plugin, let's update our test program to check whether it works

#include <stdio.h>

// Parent struct type
struct s1 {
  int field1;
  int field2;
};

// Child struct type
struct s2 {
  // Our parent type with the embed_struct attribute
  [[gnu::embed_struct]]
  struct s1 super;

  int field3;
};

int main(void) {
  struct s2 test;
  test.super.field1 = 0;
  test.super.field2 = 1;
  test.field3 = 2;

  printf("super.field1: %d\n", test.super.field1);
  printf("super.field2: %d\n", test.super.field2);
  printf("field1: %d\n", test.field1);
  printf("field2: %d\n", test.field2);
  printf("field3: %d\n", test.field3);

  return 0;
}

Time for the big reveal

$ make test
g++ -shared -I/usr/local/lib/gcc/x86_64-pc-linux-gnu/16.0.0/plugin/include -fPIC -fno-rtti -O2 plugin.c -o embedstruct.so
gcc -fplugin=./embedstruct.so test.c -o test
$ ./test
super.field1: 0
super.field2: 1
field1: 0
field2: 1
field3: 2

As you can see, field1 is linked to super.field1, and field2 is linked to super.field2. Now you can do better OOP in C without being forced into the C++ domain.

Summary

Using GCC plugins, you can modify the language to achieve some nice features. Is it worth doing? Probably not, but programming isn't always about doing things the easy way. You can check out my GitHub repository for this project (under a different name. I should probably change it sometime to a better name, but oh well).
gcc-flattenstruct
If I get time in future, I may extend this to have a few more features and better control over the layout.

Note.

Generative AI was used as a starting block for this project however it failed to do proper tasks and the resulting code is mostly mine.

Edit: After further testing, this method does allow for masking fields. Keep watch on my repository for

C is an Object-Oriented language (almost)

drflamemontgomery — Sun, 27 Apr 2025 19:53:54 +0000

What do you mean Object-Oriented?

The key concepts of Object-Oriented programming languages (OOPs) are encapsulation, inheritance, polymorphism, and abstraction. Most OOPs have straightforward, clearly defined keywords and processes for all key concepts. C does not. If you want to use OOP concepts, you will have to work for it.

Objects

Objects is C are relatively straightforward. In C, we would use structures and unions to achieve OOP.

struct Object {
  int field;
  const char *another_field;
  union {
    float f;
    int i;
  } float_or_int;
};

Encapsulation

The idea of encapsulation is to hide away data and only exposing controlled interfaces. This helps manage the state of your application and prevent the data from external modification. C does not have a good way of doing this. If you want to encapsulate data, you will have a hard time. Everything in a structure is public and if you want that changed, you might as well be using C++.

Inheritance

Building many similar objects is tedious, which is why wr have inheritance. Inheritance is the idea of creating an object that extends the functionality of another object. These extended objects are called children, which inherit properties and functionality from their parent.

In a regular OOP language, inheritance is inbuilt with keywords to make life easy. In C++ you would write classes which extend other classes.

class Animal {
  std::string name;
};

class Dog : public Animal {
  std::string breed;
};

Animal defines a field name which is a string. Dog extends Animal with the field breed, so Dog has both name and breed.

Writing the equivalent in C is fairly simple.

struct Animal {
  const char* name;
};

struct Dog {
  union {
    const char* name;
    struct Animal super;
  };
  const char *breed;
};

However, with more complex inheritance and Objects it can become messy to deal with. Which is where macros help us out.

#define struct$Object(NAME) \
  struct NAME {             \
    int field;              \
    double another_field;   \
    int an_array[8];        \
    bool last_field;        \
  }

// allows us to easily inherit the object and reference 
// as `child.FIELDNAME` while also  pushing the field
// declarations to top-level in the structure.
// i.e. `child.field` instead of `child.super.field`
#define using(TYPE, FIELDNAME) \
  union {                        \
    struct$##TYPE();             \
    struct TYPE FIELDNAME;     \
  }

struct$Object(Object); // define the structure type

struct OtherObject {
  using(Object, super);
  bool extra_field;
};

This looks like a lot more work and needlessly complex, but with a good auto formatter, it becomes easier. And it saves a lot of time and line space in future. Again, you could use C++ and make life simple. But that's less fun. If you want to use C++, you're in the wrong place.

Polymorphism

The ability to treat objects as an parent object. The most utilised form of this concept is when children override parent functions. A simple C++ example from the W3Schools C++ Polymorphism Demo

// ohttps://www.w3schools.com/cpp/trycpp.asp?filename=demo_polymorphism

// Base class
class Animal {
  public:
    void animalSound() {
      cout << "The animal makes a sound \n";
    }
};

// Derived class
class Pig : public Animal {
  public:
    void animalSound() {
      cout << "The pig says: wee wee \n";
    }
};

// Derived class
class Dog : public Animal {
  public:
    void animalSound() {
      cout << "The dog says: bow wow \n";
    }
};

int main() {
  Animal myAnimal;
  Pig myPig;
  Dog myDog;

  myAnimal.animalSound();
  myPig.animalSound();
  myDog.animalSound();
  return 0;
}

C Structures do not natively support function declarations. For C, you will have to write your own constructor functions, destructor functions, and member functions separately from the structure.

#include <stdio.h>

#define struct$Animal(NAME)                                                    \
  struct NAME {                                                                \
    void (*animalSound)(void);                                                 \
  }

#define using(TYPE, FIELDNAME)                                                 \
  union {                                                                      \
    struct$##TYPE();                                                           \
    struct TYPE FIELDNAME;                                                     \
  }

// Define the Animal structure
struct$Animal(Animal);

// Declare the default animalSound for Animal
void Animal_animalSound(void) { printf("The animal makes a sound\n"); }

// Declare a constructor for Animal
struct Animal Animal_default(void) {
  return (struct Animal){
      .animalSound = Animal_animalSound,
  };
}

struct Pig {
  using(Animal, super);
};

// Declare the default animalSound for Pig
void Pig_animalSound(void) { printf("The pig says: wee wee\n"); }

// Declare a constructor for Pig
struct Pig Pig_default(void) {
  return (struct Pig){
      .animalSound = Pig_animalSound,
  };
}

struct Dog {
  using(Animal, super);
};

// Declare the default animalSound for Dog
void Dog_animalSound(void) { printf("The dog says: bow wow\n"); }

// Declare a constructor for Dog
struct Dog Dog_default(void) {
  return (struct Dog){
      .animalSound = Dog_animalSound,
  };
}

int main(void) {
  // Setup each animal as their default
  struct Animal myAnimal = Animal_default();
  struct Pig myPig = Pig_default();
  struct Dog myDog = Dog_default();

  myAnimal.animalSound();
  myPig.animalSound();
  myDog.animalSound();
  return 0;
}

Writing polymorphism in C can vary in complexity. It all depends on where the super construct lies in the structure. If the super structure is the first field, you can automatically cast from a parent pointer to a child pointer. Otherwise you will have to calculate the offset. Some C compilers have a macro offsetof which calculates the offset of a field in a structure and therefore find the pointer of the wanted structure. To find the pointer of the structure, we can define a macro parentFromPtr.

#ifndef offsetof
#define offsetof(T, FIELD) ((size_t)&((T*)0)->FIELD)
#endif
#define parentFromPtr(T, FIELD, PTR) \
  ((T *)((size_t)PTR - offsetof(T, FIELD)))

While this macro may look daunting at first, it becomes relatively simple when you break it down. We get the address of the FIELD in the struct type T. We return it as a size_t type because we want an integer value. We cast PTR to size_t to tell our compiler we want to subtract integers instead of pointers (which would produce varying results). Then we cast the result to our struct pointer. Now we can gain the correct child pointer if the super construct isn't the first element in a struct, or if the struct extends multiple structs.

#define struct$Hero(NAME)                                                      \
  struct NAME {                                                                \
    const char *name;                                                          \
    void (*sayCatchphrase)(struct Hero *);                                     \
  }

#define using(TYPE, FIELDNAME)                                                 \
  union {                                                                      \
    struct$##TYPE();                                                           \
    struct TYPE FIELDNAME;                                                     \
  }

struct$Hero(Hero);

void Hero_sayCatchphrase(struct Hero *self) {
  printf("Never fear! %s is here!\n", self->name);
}

struct Hero Hero_create(const char *name) {
  return (struct Hero){
      .name = name,
      .sayCatchphrase = Hero_sayCatchphrase,
  };
}

struct GunSlinger {
  const char *gun_model;
  using(Hero, super);
};

void GunSlinger_sayCatchphrase(struct Hero *super) {
  struct GunSlinger *self = parentFromPtr(struct GunSlinger, super, super);
  printf("Take cover from 'The %s' or taste the lead of my %s!\n", self->name,
         self->gun_model);
}

struct GunSlinger GunSlinger_create(const char *gun_model) {
  return (struct GunSlinger){
      .gun_model = gun_model,
      .name = "Gun Slinger",
      .sayCatchphrase = GunSlinger_sayCatchphrase,
  };
}

int main(void) {
  struct Hero hero = Hero_create("Foobar");
  struct GunSlinger gun_slinger = GunSlinger_create("Revolver");

  hero.sayCatchphrase(&hero);
  gun_slinger.sayCatchphrase(&gun_slinger.super);

  return 0;
}

Abstraction

The key point of abstraction is to make code simpler and more understandable. It hides the internal details and creates high level functionality that can be easily understood and used. Abstraction is similar to encapsulation but is often thought of as an extension to encapsulation. Commonly, you see abstraction in the form of Interfaces or Abstract classes which define general characteristics. In C, every structure you create follows this pattern. You can define Interfaces as a struct with function pointers, often referred to as a virtual table. An abstract class in C is indistinguishable from a regular structure. You can create new classes to fill in structure data but you have to specify every data field.

Conclusion

C is almost an object-oriented language. You can utilize language features and macros to have a smoother OOP experience but it wasn't natively designed to have good systems in place. You miss out on easy encapsulation. Abstraction is almost always present. Inheritance requires extra work to make it a seamless transition. And polymorphism requires a good understanding of how to write function pointers. If you want an easy OOP experience, C++ or Java are far better. If you want to have complete control over your OOP system, C will force you to learn

Raspberry Pi Zero W Network Game Controller Hub

drflamemontgomery — Wed, 17 Nov 2021 21:50:01 +0000

After several weeks of searching. I finally discovered how to turn a Raspberry Pi Zero W into a USB controller.

Hardware

raspberry pi zero w

Software

raspbian-jessie-lite
raspbain-jessie
Warning Don't update your version of raspbian-jessie.

Instructions

Flash raspbian-jessie or raspbian-jessie-lite onto your raspberry pi zero w.
Connect to the wifi
Run wget -o https://github.com/drflamemontgomery/RaspberryPiZero-Controller/archive/refs/heads/main.zip
unzip RaspberryPiZero-Controller-main.zip
mv RaspberryPiZero-Controller-main/* ./
chmod +x setup.sh
sudo ./setup.sh
chmod +x hid.sh
gcc -o tcp tcp.c -lpthread
Add lines from /home/pi/rc.local to /etc/rc.local before exit 0
ifconfig
find your ip address. format is usually 192.168.1.xxx or 10.0.0.xxx
shutdown
plug your raspberry pi zero w into a device of your choice using the OTG usb port

You should now have a raspberry pi zero w acting as a network controller hub on address IP_ADDR:8080. You should now be able to connect up to 4 devices and use them as controllers.

Connecting

You can either program your own software using specifications from https://github.com/drflamemontgomery/RaspberryPi0ControllerPDF/blob/main/Raspberry_Pi_Controller.pdf or you can download https://github.com/drflamemontgomery/rpicontroller

Missile Command C++

drflamemontgomery — Thu, 20 Aug 2020 20:33:27 +0000

Hi Everyone,

I've started a project of recreating a missile command game in c++. It's being created with SFML which is a graphics library for c++.

You can check out it's progress at: https://github.com/drflamemontgomery/MissileCommand.git

feel free to post advice and feedback

Dev Website Online

drflamemontgomery — Sat, 25 Jul 2020 02:28:41 +0000

My Dev Website is now hosted on vercel for the time being.
You can access the website using the
link: https://dev-website.vercel.app

Please give feedback, criticism or both

Website in Development

drflamemontgomery — Fri, 24 Jul 2020 05:17:13 +0000

I'm making myself a developer website.

This website is going to be the main page that everyone will find me in future. My website currently isn't on a domain but is in a github repository.

Link: https://github.com/drflamemontgomery/DevWebsite

Please feel free to give feedback and or criticism.

Ps: easy way of hosting website locally is to go to the directory and type in terminal - "python -m http.server". This will allow you to access it on a web browser by going to link "localhost:8000"