DEV Community: Kshitij Srivastava

What is Intermediate Representation - A Gist

Kshitij Srivastava — Thu, 30 May 2024 04:16:00 +0000

Here's a problem statement: What if you have a programming language specification and want to write a compiler for it? What about if you have two languages? Or, three? Or more?

While each language is quite different to each other, all of them will have some similarities under the hood. Sure, there may be simple changes like basic syntax and file structure. And, there may be more complex changes like variable hoisting rules, lifetimes and garbage collection but, when everything is stripped away, your code has to be eventually converted into something machine readable anyway.

#include <iostream>

int main(void) {
    const std::string message = "Hello, world!";
    std::cout << message << std::endl;

    return 0;
}

const message = 'Hello, world!';
console.log(message);

These two snippets might look different, and that's because they are probably the farthest apart (apart from perhaps a functional language) as you can get in programming languages without going into the deep end. And yet, an ideal IR aims to unify these in a single, complete and non-lossy format.

So, why not try to write a generic compiler for everything? The refinement of this idea could be implemented using intermediate representation, or IR.

What is IR?

Contrary to popular belief, IR is not necessarily a programming language but could either be a data-structure (abstract-syntax trees) or code used internally by a compiler to represent the true source code.

The LLVM project is probably the most popular example of a widely-used IR: the LLVM IR.

LLVM consists of three major parts: the frontends, the IR and the backends. The frontends' job is to take source code from the native language and convert it into LLVM IR. And the job of the various backends is to generate machine code from LLVM IR that targets the required instruction set.

Why IR?

The biggest, and most prevalent reason to use an IR is common optimisations. If the true language source code can be converted into an IR, a general set of optimisations can be performed on that IR. This is opposed to the traditional method which would mean writing language-specific optimisations for every compiler frontend.

The second major benefit of IR is that it enables just-in-time (JIT) and ahead-of-time (AOT) compilation depending on the use case.

Here's an example of the crux of the LLVM IR for a simple C "Hello, world" program.

#include <stdio.h>

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

@.str = private unnamed_addr constant [15 x i8] c"Hello, world!\0A\00", align 1

; Function Attrs: noinline nounwind optnone uwtable
define dso_local i32 @main() #0 {
  %1 = alloca i32, align 4
  store i32 0, ptr %1, align 4
  %2 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  ret i32 0
}

declare dso_local i32 @printf(ptr noundef, ...) #1

Things I Wish They Taught Us About C in College

Kshitij Srivastava — Sat, 13 Apr 2024 11:05:16 +0000

The first programming course in my college and I'm sure in a lot of others was "Programming in C" and for good reason. Like it or not, C is one of the most important programming languages to learn as a budding computer scientist.

Programming in C begins to teach you (the hard way) how software actually works and if you've programmed before, makes you appreciate the beauty of some high-level features in languages that you've probably taken for granted this whole time.

However, as is the case with most exuberant college students, we want to learn programming, not computer science (a discussion perhaps, for another day) and learning C doesn't inspire confidence in building actual software that actual people will use.

Contrary to popular belief however, C is a really easy language to learn and once you've got a hang of the fundamentals, is really easy to build actual software with. The issue lies in the way it is taught in an academic setting. A lot of the quality of life features of the language are glossed over and leave students scared of it.

Here are some features that I wish they taught us in college that make C seem more approachable and help you use it not just as a computer scientist, but an actual programmer.

stdint.h et al

Kshitij Srivastava ・ Mar 29

#c #codequality #beginners

Using Const

Kshitij Srivastava ・ Apr 13

#c #codequality #beginners

Using typedef

Kshitij Srivastava ・ Apr 13

#c #codequality #beginners

Saving Magic for Macros

Kshitij Srivastava ・ Apr 13

#c #codequality #beginners

Saving Magic for Macros

Kshitij Srivastava — Sat, 13 Apr 2024 11:04:42 +0000

We often find ourselves in the middle of writing a function that we cannot bring ourselves to simplify further. The ones which end up relying on some kind of inexplicable "magic" that cannot be abstracted away.

Instead of writing these as functions, consider using macros instead. Let me give you a taste of what they are capable of.

Macros are defined using the #define directive and are effectively a copy-paste replacement where they are used with appropriate parameter substitutions.

#include <stdio.h>

#define PRINT_MESSAGE(message) printf("%s\n", (message))

int main(void) {
    PRINT_MESSAGE("Hello, world!");
    return 0;
}

Macros are incredibly powerful since they accept any token as a parameter. So, you could potentially also do this.

#define PERFORM_OPERATION(number_1, number_2, operator) \
    ((number_1) operator (number_2))

int main(void) {
    int a = PERFORM_OPERATION(1, 2, +);  // 3
    int b = PERFORM_OPERATION(1, 2, -);  // -1
    int c = PERFORM_OPERATION(5, 2, *);  // 10
    int c = PERFORM_OPERATION(4, 2, /);  // 2

    return 0;
}

But, my personal favourite use of macros is to create generic versions of certain often used procedures. Here's one that is used to swap two values of any given data type.

#include <stdbool.h>
#include <stdlib.h>

#define SWAP(value_1, value_2, type)\
    do\
    {\
        type* temp = malloc(sizeof(type));\
        *temp = value_1;\
        value_1 = value_2;\
        value_2 = *temp;\
        free(temp);\
    }\
    while (false)

Let me try to explain the weirdness. Since we're creating a variable and since macros are effectively a copy-paste substitution, we have to limit the variable's scope. So, we can place it in a separate block like this do-while block that only executes once.

This function would have been a pain to write normally since there is no direct way to pass the data-type to a function in C. In situations like this, it is often much easier to write a simple macro than to create multiple long and similar functions.

Using typedef

Kshitij Srivastava — Sat, 13 Apr 2024 10:53:22 +0000

typedef is one of things that I can never look back from. Essentially, it allows to alias existing types in C and makes code much easier to read and write.

Take the following example as an instance.

struct my_struct {
    int a;
    char b;
}

void init_my_struct(struct my_struct* s, int a, char b);

Now, we alias the my_struct to another value using typedef.

typedef struct my_struct {
    int a;
    char b;
} my_struct_t;

void init_my_struct(my_struct_t* s, int a, char b);

Notice how much easier it is to follow code. You may also omit the initial name declaration of my_struct but I personally prefer it since it gives static analysis tools more information about the struct as opposed to just an anonymous struct. The same may be used for any type, even enums. But, I feel the best use of typedef is aliasing pointers to functions.

typedef enum color {
    COLOR_RED,
    COLOR_GREEN,
    COLOR_BLUE
} color_t;

void display_value(color_t display_color);

The syntax behind them is confusing and weird and stems partly from the notion of "declaration reflects use" but is still strange. Aliasing these behemoths to something much easier to the eye is always welcome.

typedef void (*ParseFunction)();

Using Const

Kshitij Srivastava — Sat, 13 Apr 2024 10:36:55 +0000

An important factoring in understanding your code is realising what is mutable and when. Often times, variables we use in code do not need to change or, should not be changed.

C uses the const keyword to signify that a variable cannot be mutated. You may have seen this when making strings, const char*.

But, using const brings up the important discussion of mutability in programs, leading to large online debates about the essence of programming.

There are those who believe that code is nothing but mathematics and such, should not have mutable state at all. Once a variable is declared and initialised, its value cannot and should not change.

On the other side, there are those who say that this approach only works on white-papers and technical documents and that in the real world, with real-time communication to databases and APIs, it is nearly impossible to write pure code.

In any case, realising the importance of constant values is important as a programmer and using const for such values encourages writing cleaner code.

While using const rarely has any performance benefits, it is important to consider its benefits on developer experience. const enforces the idea of constants as opposed to being left as overhead to the programmer.

// Constant parameters.
void do_something(const int data) {
    ...
}

int main(void) {
    // Constant local variables.
    const int number = 5;

    // Constant pointers.
    const char* message = "Hello, world!\n";

    return 0;
}

stdint.h et al

Kshitij Srivastava — Fri, 29 Mar 2024 20:21:20 +0000

One of the first things to realise about C is that a lot of important things are left as implementation details. The C standard doesn't actually define the size of an int, or a float or even a char for that matter. Add to the fact that the notion of a simple boolean value doesn't really exist as part of its core data-types.

So, a header file called stdint.h was introduced in C99 to allow programmers to write code with typedefs for common data-types that specified their underlying sizes.

This allowed for programmers to write code with data-types independent of the architecture of their target machines. This is especially useful for a language like C that is designed to run on the smallest of embedded systems all the way to the fastest of supercomputers.

An integer on any modern 64-bit machine takes up 32-bits by default. So, for consistency's sake, instead of using int, use int32_t or, instead of char, use uint8_t which, as the name hints, refers to an unsigned 8-bit integer, which is sufficient to store any possible ASCII character.

#include <stddef.h>
#include <stdint.h>

int main(void) {
    int number_1 = 5;  // ambiguous size (depends on platform)
    int32_t number_2 = 10;  // fixed 32-bit size on all platforms

    char character_1 = 'a';  // mostly 8-bits (but on some embedded architecture, you never know!)
    uint8_t character_2 = 'b';  // fixed 8-bit size on all platforms

    size_t length = 5;
    int32_t* array = malloc(sizeof(int32_t) * length);

    for (size_t i = 0; i < length; i++) {
        array[i] = i;  // No fear that i can ever go out of bounds.
                       // Also note the implicit type-cast from size_t to int32_t.
    }

    free(array);

    return 0;
}

This also extends to using size_t and bool from 'stddef.h' and 'stdbool.h' respectively. The latter, as is obvious is just a typedef over 0 for false and 1 for true to make it more clear whether something is a boolean and to disallow any other value on accident if using something less restrictive, like an int.

size_t is where things get more interesting. Officially defined as an unsigned integer of a size that is at least 16-bits, it is used to define the size of objects. That doesn't seem very platform independent, does it? Well, it's not supposed to be.

size_tis great at holding object sizes and of particular note is its use in representing array lengths, and therefore, array indices. Instead of using an int which may either be negative, or either too big, or too small, size_t remains the perfect data-type to use in such scenarios.

Another nice use of size_t is that it is meant to represent the size of any data-type by design. So, the sizeof operator must return a value compatible with size_t.