book

Learn LLVM 12

Name: Learn LLVM 12
Author: Kai Nacke
ISBN: 9781839213502

by Kai Nacke

May 2021

Beginner to intermediate

392 pages

8h 6m

English

Packt Publishing

Read now

Unlock full access

Learn LLVM 12
ContributorsAbout the authorAbout the reviewer
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesCode in ActionDownload the color imagesConventions usedGet in touchReviews
Section 1 – The Basics of Compiler Construction with LLVM
Chapter 1: Installing LLVM
Getting the prerequisites readyUbuntuFedora and RedHatFreeBSDOS XWindowsConfiguring GitBuilding with CMakeCloning the repositoryCreating a build directoryGenerating the build system filesCustomizing the build processVariables defined by CMakeVariables defined by LLVMSummary
Chapter 2: Touring the LLVM Source
Technical requirementsContents of the LLVM mono repositoryLLVM core libraries and additionsCompilers and toolsRuntime librariesLayout of an LLVM projectCreating your own project using LLVM librariesCreating the directory structureAdding the CMake filesAdding the C++ source filesCompiling the tinylang applicationTargeting a different CPU architectureSummary
Chapter 3: The Structure of a Compiler
Technical requirementsBuilding blocks of a compilerAn arithmetic expression languageFormalism for specifying the syntax of a programming languageHow grammar helps the compiler writerLexical analysisA handwritten lexerSyntactical analysisA handwritten parserThe abstract syntax treeSemantic analysisGenerating code with the LLVM backendTextual representation of the LLVM IRGenerating the IR from the AST The missing pieces – the driver and the runtime librarySummary
Section 2 – From Source to Machine Code Generation
Chapter 4: Turning the Source File into an Abstract Syntax Tree
Technical requirementsDefining a real programming languageCreating the project layoutManaging source files and user messagesStructuring the lexerConstructing a recursive descent parserGenerating a parser and lexer with bison and flexPerforming semantic analysisHandling the scope of namesUsing LLVM-style RTTI for the ASTCreating the semantic analyzerSummary
Chapter 5: Basics of IR Code Generation
Technical requirementsGenerating IR from the ASTUnderstanding the IR codeKnowing the load-and-store approachMapping the control flow to basic blocksUsing AST numbering to generate IR code in SSA formDefining the data structure to hold valuesReading and writing values local to a basic blockSearching the predecessor blocks for a valueOptimizing the generated phi instructionsSealing a blockCreating IR code for expressionsEmitting the IR code for a functionControlling visibility with linkage and name manglingConverting types from an AST description to LLVM typesCreating the LLVM IR functionEmitting the function bodySetting up the module and the driverWrapping everything in the code generatorInitializing the target machine classEmitting assembler text and object codeSummary
Chapter 6: IR Generation for High-Level Language Constructs
Technical requirementsWorking with arrays, structs, and pointersGetting the application binary interface rightCreating IR code for classes and virtual functionsImplementing single inheritanceExtending single inheritance with interfaces Adding support for multiple inheritanceSummary

Chapter 7: Advanced IR Generation
Technical requirementsThrowing and catching exceptionsRaising an exceptionCatching an exceptionIntegrating the exception-handling code into the applicationGenerating metadata for type-based alias analysisUnderstanding the need for additional metadataAdding TBAA metadata to tinylangAdding debug metadataUnderstanding the general structure of debug metadataTracking variables and their valuesAdding line numbersAdding debug support to tinylangSummary
Chapter 8: Optimizing IR
Technical requirementsIntroducing the LLVM Pass managerImplementing a Pass using the new Pass managerAdding a Pass to the LLVM source treeAdding a new Pass as a pluginAdapting a Pass for use with the old Pass managerAdding an optimization pipeline to your compilerCreating an optimization pipeline with the new Pass managerExtending the Pass pipelineSummary
Section 3 –Taking LLVM to the Next Level
Chapter 9: Instruction Selection
Technical requirementsUnderstanding the LLVM target backend structureUsing MIR to test and debug the backendHow instruction selection worksSpecifying the target description in the TableGen languageInstruction selection with the selection DAGFast instruction selection – FastISelThe new global instruction selection – GlobalISelSupporting new machine instructionsAdding a new instruction to the assembler and code generationTesting the new instructionSummary
Chapter 10: JIT Compilation
Technical requirementsGetting an overview of LLVM's JIT implementation and use casesUsing JIT compilation for direct executionExploring the lli toolImplementing our own JIT compiler with LLJITBuilding a JIT compiler class from scratchUtilizing a JIT compiler for code evaluationIdentifying the language semanticsSummary
Chapter 11: Debugging Using LLVM Tools
Technical requirementsInstrumenting an application with sanitizersDetecting memory access problems with the address sanitizerFinding uninitialized memory access with the memory sanitizerPointing out data races with the thread sanitizerFinding bugs with libFuzzerLimitations and alternativesPerformance profiling with XRayChecking the source with the Clang Static AnalyzerAdding a new checker to the Clang Static AnalyzerCreating your own Clang-based toolSummary
Chapter 12: Create Your Own Backend
Technical requirementsSetting the stage for a new backendAdding the new architecture to the Triple classExtending the ELF file format definition in LLVMCreating the target descriptionImplementing the top-level file of the target descriptionAdding the register definitionDefining the calling conventionCreating the scheduling modelDefining the instruction formats and the instruction informationImplementing the DAG instruction selection classesInitializing the target machineAdding the selection DAG implementationSupporting target-specific operationsConfiguring the target loweringGenerating assembler instructionsEmitting machine codeAdding support for disassemblingPiecing it all togetherSummary
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youLeave a review - let other readers know what you think

Content preview from Learn LLVM 12

Chapter 10: JIT Compilation

The LLVM core libraries come with the ExecutionEngine component, which allows the compilation and execution of IR code in memory. Using this component, we can build just in time (JIT) compilers, which allow the direct execution of IR code. A JIT compiler works more like an interpreter, in the sense that no object code needs to be stored on secondary storage.

In this chapter, you will learn about applications for JIT compilers, and how the LLVM JIT compiler works in principle. You will explore the LLVM dynamic compiler and interpreter, and you will also learn how to implement a JIT compiler tool on your own. You will also see how to make use of a JIT compiler as part of a static compiler, and the challenges associated ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781839213502

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learn LLVM 12

by Kai Nacke

Chapter 10: JIT Compilation

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.