Features/Meson/Design

Rules.mak has gotten insane, let's get rid of it!

More seriously, the current build system causes clutter in the toplevel Makefiles, and it makes simple tasks harder than they should be. For example, each executable in contrib/ has to touch three files: Makefile, Makefile.objs and contrib/*/Makefile.objs.

Meson has several advantages that directly matter for QEMU including the following:

• build definitions in a very readable and user friendly DSL, which supports looping and conditions
• ability to introspect the build definitions so that you can find out what is built without building it (the DSL is not Turing complete and most objects in it are immutable, so it cannot be abused that much :))
• support for a non-recursive build from per-subdirectory input (similar to Makefile.objs)
• strong checking of prerequisites when Meson is run, so that it's usually unnecessary to debug whatever files Meson generates
• ease of distributing a full copy of Meson to support distros that ship an older version (no dependencies apart from Python 3.5).

The transition is designed around the following goals:

• the build system should make it trivial to do trivial things; easy to do things that are a matter of cut-and-paste from something that already exist; possible to do everything else.
• it should remain trivial to do things that used to be trivial, and most "make" invocations should be kept the same at least until everything is converted (and we can perhaps declare a flag day). It should not become harder to do things that are a matter of cut-and-paste.
• it should be possible to modify meson.build without knowing QEMU specific details, and that should be already possible now at the beginning of the transition (to avoid creating technical debt). This means keeping the magic confined in Makefile rules and external scripts, while having a pretty plain meson.build.

A PoC was posted in June 2019. It includes a program called "ninjatool" that replaces ninja for the few cases where meson invokes it directly (ninja -t compdb, ninja -t clean) and that also is able to convert build.ninja files to Make syntax. Because of this, it is trivial to have make build products that depend on meson build products. Therefore bottom up is the natural direction for the conversion.

This fits in a generic plan to drop Makefile magic in favor of build rule generators written in high-level languages. For example, in order to keep make check-like rules working, we could generate Makefile rules from the output of meson introspect --tests. This, together with the use of ninja2make also gives us an escape mechanism in case we want to do something that Meson cannot (yet) do, or doesn't do the way we want it.

The alternative of having two parallel build systems was rejected. This would introduce extra work for people not involved in the conversion, and the risk of bitrotting one of the two build systems is large.

Issues

Meson

Included in 0.51.0:

• Support a NINJA environment variable
• Kconfig Module (still named "unstable-kconfig", should be stabilized before QEMU switches to meson)
• new module "sourceset" to match source file lists against configuration data
• Script found by find_program() does not end up in dependencies
• do not include host environment in test/benchmark introspection data

Included in 0.52.0:

• Ugly command lines for custom targets with capture.
• vs_module_defs for modules
• Allow kconfig to read from built files
• all_dependencies method for sourceset

Planned for 0.52.0:

• Add multiple inputs to configure_file()
• Add depfile to configure_file()

Others:

• Do we need to know where our modules end up in the build dir, to be able to have a working dev version of QEMU?
• Target file name must not contain a path separator - makes it impossible to generate e.g. audio/trace.h. Ideas:
  • add something that behaves like "generator()" but generates custom_targets
  • generate files like trace/trace-audio.h and add one-line forwarding header files so that we can keep the #include "trace.h" idiom.

QEMU

• Deprecate in-tree build? Meson only supports out-of-tree.

Coding style

• Libraries (static or found with cc.find_library) should be named libfoo.
• Dependencies (defined with either dependency or declare_dependency should not have the lib prefix.
• Sourcesets should be named foo_ss.
• Do not use disablers.
• Do not use dependency unless you are able to remove the corresponding variable from config-host.h.
• Use files('aa', 'bb'), not files('''aaa bbb'''.split())

Status

• PoC: https://patchew.org/QEMU/1562775267-1222-1-git-send-email-pbonzini@redhat.com/
  • converted libqemuutil.a, trace, QAPI
  • converted some of contrib/
• Next PoC status (see above for pending Meson 0.52.0 pull requests):
  • converted qemu-ga
  • converted remaining contrib/ and tools
  • support ui/audio/block module bulding
  • started conversion of emulators
• Before posting next version:
  • (done) consistent coding style
  • (mostly done) extract changes that are independent of the conversion to separate patches
  • (done) commonize code for modules
  • (done) move scripts/create_config invocation from rules.mak to meson
  • (done) Makefile.ninja rebuild rules are trigger-happy
  • Generate .stp files from Meson.
  • create modules in build directory without using common-obj-m (which would disappear sooner or later)
• Before merging:
  • Paolo: rebase to a newer version of QEMU (will do after fixing triggering of reconfigure rules)
  • ship Meson as a submodule
  • Paolo: support Meson tests in make check (converting meson introspection data to Makefile rules, e.g. Meson suite unit goes into the Make check-unit target)
• After merging:
  • finish conversion of emulators
  • create windowed/console variants of Windows executables
  • convert configure tests
  • convert tests
  • convert installation of data files