Kai Nacke

A close look at IR code generation inside a Modula-2 compiler.

With LLVM, one of the main tasks of an compiler engineer is to design the IR code generation from an abstract syntax tree (AST). How easy is it? Although I have worked with and on LLVM for several years now I have not yet written an compiler from scratch. So I began to work on my own compiler for an simple yet powerful language: Modula-2. In this talk I introduce the architecture of the m2lang compiler. My main focus is the generation of basic blocks and IR code from the AST. I show which general patterns emerged and which areas of the languages caused trouble. I also give hints when it is useful to introduce yet another intermediate language between the AST and the IR.

GPU programming is popular with scientists who need massive parallel computing power. DCompute is an extension of LDC, the LLVM-based D compiler, which uses the PTX and SPIR-V targets of LLVM for a smooth integration in a system programming language.

GPU programming is popular with scientists who need massive parallel computing power. However, programming requires learning new programming languages and integrating additional compilers into the build system, making it difficult to use. Since LLVM supports GPU targets, it makes sense to extend an existing compiler. DCompute is an extension of LDC, the LLVM-based D compiler. This allows the user to write OpenCL and CUDA kernels in D. In this talk, I show what steps were necessary to integrate not only the code generation for conventional CPUs but also the code generation for GPUs. I also look at where the use of LLVM could be improved and which challenges still exist in LLVM.

Profile-Guided Optimization (PGO) is an optimization technique which uses information about the runtime profile of an application. PGO is an area of active development in LLVM. In this talk I discuss how PGO was implemented in LDC, the LLVM-based D compiler, and which speedup the use of PGO can give.

Profile-Guided Optimization (PGO) is an optimization technique which uses information about the runtime profile of an application. The binary of an application is instrumented to collect data like number of times a function is called. This additional information is used to apply advanced optimizations to the application. PGO is an area of active development in LLVM. A recent update of LDC, the LLVM-based D compiler, is able to use PGO. In this talk I discuss which additonal IR code must be generated for PGO and how it was implemented in LDC. I also show the effect of PGO on a test application and the compiler itself.

LLVM is available for many CPU architectures. In this talk I share my experience in porting LLVM to a new OS based on a supported CPU architecture.

LLVM is available for many CPU architectures. Because there exists many different OSs you may encounter the situation that the CPU architecture of your OS is supported but not your OS itself. In order to natively run LLVM on such an OS you need to port LLVM. In this talk I share my experience in porting LLVM to AIX. LLVM supports Linux on PowerPC so aiming for AIX supports seems reasonable. I show the approach I took and which parts of LLVM must be modified, including how to tweak the MC layer to utilize an external assembler.

Using LLVM on a new CPU or a new platform may require changes to the internal assembler. A common use case is the support of new instructions for a new CPU. In this talk I show how to add a complete new CPU feature, using the MIPS Octeon variant as an example.

LLVM has an integrated assembler in the MC layer. If a CPU vendor adds new instructions then it is necessary to extend the instruction description in order to use the new instructions at least in inline assembly. It would be even better if these instructions are also considered by the code generation. In this talk I show how to add a new CPU feature, new instructions and instruction aliases. I also demonstrate how the new instructions are selected by the code generation. As example I use the Octeon instructions which I added to the MIPS backend for the LLVM 3.5 release.

D is a language with C-like syntax and static typing. It pragmatically combines efficiency, control, and modeling power, with safety and programmer productivity. LDC is a fully open source, portable D compiler which uses LLVM as backend. In my talk, I will introduce the overall architecture of LDC first. I will then use the mapping of the front end AST to LLVM IR to show the required LLVM features. Experiences with LLVM in general, porting to other LLVM backends and integrating features like the AddressSanitizer are highlighted. At last, areas of improvement for LLVM are shown from the perspective of a D compiler (ABI, vararg, exception handling).

D is a language with C-like syntax and static typing. It pragmatically combines efficiency, control, and modeling power, with safety and programmer productivity. Because of its features major companies start to adopt D.

LDC is a fully open source, portable D compiler. It uses the frontend from the reference compiler combined with LLVM as backend to produce efficient native code. LDC targets x86/x86_64 systems like Linux, OS X and Windows and also Linux/PPC64. Ports to other architectures like ARM are underway. Currently, LDC can be built with LLVM 3.1 and all later LLVM releases.

In my talk, I introduce the overall architecture of LDC first. Using the frontend AST as starting point I show how types, statements and expression are mapped to LLVM IR and which LLVM features are required. Experiences with LLVM in general, porting to other LLVM backends than x86 and integrating features like the AddressSanitizer are highlighted. At last, areas of improvement for LLVM are shown from the perspective of a D compiler (ABI, vararg, exception handling).