Fil-C as a compiler target for managed languages

Fil-C is a memory safe dialect of C that comes with an integrated garbage collector. That makes it an interesting compiler target for managed languages.

Where I’m coming from

I’d already been thinking about creating a new programming language for a long time when I started. As it got closer, I tried to anticipate what the main obstacles would be and prepare for them.

I already had knowledge of and experience with optimization and code generation, so I was comfortable with that. There are also open source backends such as LLVM to build on.

Parsing didn’t worry me either. I had already written several little parsers for toy languages, either for practise or to explore some new concept. I knew to avoid parser generators after having tried Antlr many years ago. Antlr is very good for what it is, but it’s much better to write a recursive descent parser by hand, or using a parser combinator library.

The search for a good collector

I expected garbage collection to be the biggest challenge to overcome. I’d read enough to know it’s not a small feat to get good performance.

There are open source collectors I could use but I wasn’t very enthusiastic about any of them. The Boehm collector is the most widely used, but I had a negative impression of it going back a long time. It just seemed every program built on it was buggy and slow.

I was also aware of the Memory Pool System (MPS) and while it’s both fast and reliable, it didn’t use to have a permissive license. Nowadays it does, though.

I was delighted to discover the Perceus algorithm maybe a year before I started. Here was a solution that was easy to implement, didn’t add a complex dependency to the project, and was said to be competitive with GCs that had been tuned for years! However, I never got around to implementing it and gradually became disillusioned with it. I realized it was designed to solve problems caused by idioms in functional programming languages, such as iterating over a recursive data structure and allocating copies of every node. But it seems better to encourage efficient idioms, such as for loops and dynamic arrays.

Fil-C

When Fil-C was announced I was intrigued that it’s possible to make a memory safe C, but I overlooked the fact it comes with a garbage collector. That aspect of it doesn’t get as much attention. I guess because more people are looking for a safer C than for a C with garbage collection. But for managed languages with performance aspirations it’s actually a very good fit, if nothing else as a stepping stone.

By generating C and compiling with Fil-C I hope to get competitive performance for minimal effort. Not as fast as MPS, but close enough. The fact it was designed as a drop-in solution for legacy programs means it doesn’t require any additional work beyond generating C.

Closing words

Before I get to that though, I need to finish the front end of the compiler. My prediction that memory management would be the biggest challenge was probably false, given how much time I’ve already spent on the type system and related aspects of the front end, such as overloading.

Over the past few years I’ve also become more interested in compiling to other managed languages, mainly Javascript and Wasm. I think my strong focus on machine code initially was a holdover from when I started thinking about these things 20 years ago, before the web became what it is.

I already have a prototype backend for JS actually. More about that when I have time to revisit it.

Stefan