Creating an optimization pipeline – Optimizing IR-1

The tinylang compiler we developed in the previous chapters performs no optimizations on the IR code. In the next few subsections, we’ll add an optimization pipeline to the compiler to achieve this accordingly.
Creating an optimization pipeline
The PassBuilder class is central to setting up the optimization pipeline. This class knows about all registered passes and can construct a pass pipeline from a textual description. We can use this class to either create the pass pipeline from a description given on the command line or use a default pipeline based on the requested optimization level. We also support the use of pass plugins, such as the ppprofiler pass plugin we discussed in the previous section. With this, we can mimic part of the functionality of the opt tool and also use similar names for the command-line options.
The PassBuilder class populates an instance of a ModulePassManager class, which is the pass manager that holds the constructed pass pipeline and runs it. The code generation passes still use the old pass manager. Therefore, we have to retain the old pass manager for this purpose.
For the implementation, we will extend the tools/driver/Driver.cpp file from our tinylang compiler:

1. We’ll use new classes, so we’ll begin with adding new include files. The llvm/Passes/PassBuilder.h file defines the PassBuilder class. The llvm/Passes/PassPlugin.h file is required for plugin support. Finally, the llvm/Analysis/TargetTransformInfo.h file provides a pass that connects IR-level transformations with target-specific information:

include “llvm/Passes/PassBuilder.h”
include “llvm/Passes/PassPlugin.h”
include “llvm/Analysis/TargetTransformInfo.h”

2. To use certain features of the new pass manager, we must add three command-line options, using the same names as the opt tool does. The –passes option allows the textual specification of the pass pipeline, while the –load-pass-plugin option allows the use of pass plugins. If the –debug-pass-manager option is given, then the pass manager prints out information about the executed passes:

static cl::opt
DebugPM(“debug-pass-manager”, cl::Hidden,
cl::desc(“Print PM debugging information”));
static cl::opt PassPipeline(
“passes”,
cl::desc(“A description of the pass pipeline”));
static cl::list PassPlugins(
“load-pass-plugin”,
cl::desc(“Load passes from plugin library”));

3. The user influences the construction of the pass pipeline with the optimization level. The PassBuilder class supports six different optimization levels: no optimization, three levels for optimizing speed, and two levels for reducing size. We can capture all levels in one command-line option:

static cl::opt OptLevel(
cl::desc(“Setting the optimization level:”),
cl::ZeroOrMore,
cl::values(
clEnumValN(3, “O”, “Equivalent to -O3”),
clEnumValN(0, “O0”, “Optimization level 0”),
clEnumValN(1, “O1”, “Optimization level 1”),
clEnumValN(2, “O2”, “Optimization level 2”),
clEnumValN(3, “O3”, “Optimization level 3”),
clEnumValN(-1, “Os”,
“Like -O2 with extra optimizations “
“for size”),
clEnumValN(
-2, “Oz”,
“Like -Os but reduces code size further”)),
cl::init(0));

4. The plugin mechanism of LLVM supports a plugin registry for statically linked plugins, which is created during the configuration of the project. To make use of this registry, we must include the llvm/Support/Extension.def database file to create the prototype for the functions that return the plugin information:

define HANDLE_EXTENSION(Ext) \
llvm::PassPluginLibraryInfo getExtPluginInfo();
include “llvm/Support/Extension.def”