This Weekend in Meson++ (January 15th)

 It's been a while, so this is going to cover more than a weekend, but I've hit some nice milestones, and it's pretty exciting. 

Let's talk about phi nodes.

I'm not an expert on phi's, but basically they're a way to represent values that change in branched code, without actually computing them. In a way it's a sort of "promise" of a value.

if y₁
  X₁ = true
else
  X₂ = false
endif
X₃ = ϕ(X₁, X₃)

In this case, until we can resolve Y we can't know what X is, it could be true or false. The Phi node lets us represent that by creating a new version of X, which is either true or false. Then, when we can prune the branches down to one value of X, we can propagate out the value of X that wasn't erased. This is pretty much the thing that makes SSA possible, and what makes it awesome.

This then makes two more important passes really easy, constant folding and constant propagation. The First pass allows us to take variable aliases and fold them up, so consider The above. If y₁ resolves to true, then we know that X₃ == X₁, and we can fold up that all up. Or if we have a case like

X₁ = dependency('', required : false)
Y₁ = X₁
Z₁ = Y₁

We know that Z₁ is actually X₁ and can fold that up.

Then we can propagate out variables into their uses as well,

X₁ = 7
Y₁ = 9 
Z₁ = [X₁, Y₁]

In this case we can propagate the values of X₁ and Y₁ into Z₁, and eliminate them. This works really well for Meson, which is mostly immutable objects with shadowing. What remains is copy on assignment, like `configuration_data`.

Now that that is (mostly) in place we start reducing the instructions in our IR, and combining them. This is particularly important for making things like linking work. After all, most targets are in fact defined in the form like

lib = static_library(...)
main = executable(..., link_with : lib)

In this case, we need to be able to put lib into the main executable, which you can see we can now solve.

Build Targets and Include Directories

Now that we have phi nodes, const folding, and const propagation, it's possible to start linking things. Which is now possible. I only have executables and static libraries currently, but I've done some cleanups using templates to simplify code sharing between them. And c++17's constexpr comes to the rescue here.

This allows us to write awesome code like
template <typename T>
T build_target(const Object & obj) {
  if constexpr (std::is_same<T, Executable>::value) {
    ...
  } else {
    ...
  }
}
And the c++ compiler will resolve that conditional at compile time. This makes it much easier to specialize templates for specific cases while sharing the majority of the code that's the same. This is especially true for cases like meson's build targets, where they're mostly the same, but with small differences between them.

I've also added support for include_directories, so now you can have headers. Because those are useful.

Messages, Warnings, and Errors

Also, present now are support for message, warn, and error, though only if using string values or arrays of strings. There's more work to specialize the flattening pass to not act on message functions, but that's a down the road kind of problem.

What's next?

I'm working on find_program, getting method calls actually working, and assert. Stay tuned for the next irregular installment of this "This Weekend in Meson++"

Comments

Post a Comment

Popular posts from this blog

This Weekend in Meson++ (February 6th)

 Meson++ is 1 year old! It's strange to think that February 9th, 2021, was the first commit to meson++, and a year later, we have a working flex+bison C++ frontend, an optimizing mid level IR, a file based backend IR, and the ability to generate simple ninja programs! It's a strange and proud feeling.  Anyway, I haven't implemented any sweepingly huge features this week, but we have landed support for `declare_dependency`, an important first step toward real dependencies (like those found by pkg-config). I also implemented a simple optimization for finding unreachable code. In this case, we look for the `error` function, and mark any instructions after that as dead, as well as removing any next block. Currently, there are no other non-returning functions implemented, but eventually `subdir_done()` will also need to be handled (though `subdir_done()` may present other problems for me). I also started implementing some neat argument pack based variant argument extractors. The
Read more

Introducing Meson++

I've been semi-quietly working on a new project for the last few months on and off, and today I've gotten far enough that I want to talk about it more widely: Meson++ . Meson++ is now capable of compiling very simply projects, if they meet the following criteria:  they use only C++ they don't have any external dependencies they only build executables they don't do any code generation you're okay using ninja you're using clang or gcc This may seem like a lot of restrictions, and it is, but there's a lot of code that has gone into getting to this point. I'd like to thank stackoverflow for answering a lot of questions. Motivation My primary motivation is to solve bootstrapping issues, imagine if python wanted to use Meson, currently that would create a bootstrap loop, where you need an old version of python to run an old version of Meson, etc. Or, imagine you want to build something like your compiler with Meson, now you need to build python bef
Read more

Rust in Meson — 0.57 Edition

Rust in Meson 0.57 Most people by now have heard of the meson build system I hope (at least anyone who would bother to read this blog post), and Rust is the cool new language everyone wants to use because it guards against specific kinds of memory bugs and has some neat features. The question of course is how to add rust to your existing project using C, C++ or another language. The answer of course, should be build your project with meson. I’m not going to go into whether using Rust is a good idea, whether it’s going to solve all of your problems, eat your puppy, or any of that. Rust, like everything else we do in programming comes with a set of trade-offs. I’ll say though, for the record, that I like Rust as a programming language form the relatively small amount of it I’ve done. So here’s a run down of what’s coming in the meson 0.57.0 release for Rust. Meson level handling for rust editions. Rust editions, for the uninitiated, are roughly equivalent to standards in C and C++.
Read more