book

Getting started with LLVM core libraries

by Bruno Lopes, Rafael Auler

August 2014

Beginner to intermediate

314 pages

7h 57m

English

Packt Publishing

Read now

Unlock full access

Support files, eBooks, discount offers, and moreWhy subscribe?Free access for Packt account holders
What this book covers

Downloading the example codeErrataPiracyQuestions
Understanding LLVM versions
Obtaining the official prebuilt binariesUsing package managersStaying updated with snapshot packagesLinuxWindows
System requirementsObtaining sourcesSVNGitBuilding and installing LLVMUsing the autotools-generated configure scriptBuilding and configuring with UnixUsing CMake and NinjaBuilding with Unix using CMake and NinjaSolving build errorsUsing other Unix approachesWindows and Microsoft Visual StudioMac OS X and Xcode
Introducing Clang extrasBuilding and installing Clang extra toolsUnderstanding Compiler-RTSeeing Compiler-RT in action
Building DragonEggUnderstanding the compilation pipeline with DragonEgg and LLVM toolsUnderstanding the LLVM test suiteUsing LLDBExercising a debug session with LLDBIntroducing the libc++ standard library
Introducing LLVM's basic design principles and its history
Getting to know LLVM's basic librariesIntroducing LLVM's C++ practicesSeeing polymorphism in practiceIntroducing C++ templates in LLVMEnforcing C++ best practices in LLVMMaking string references lightweight in LLVMDemonstrating the pluggable pass interface
Writing the MakefileWriting the code
Understanding the code as a documentationAsking the community for helpCoping with updates – using the SVN log as a documentationConcluding remarks
Introducing ClangFrontend actionsLibrariesUsing libclangUnderstanding Clang diagnosticsReading diagnostics
Lexical analysisExercising lexical errorsWriting libclang code that uses the lexerPreprocessingSyntactic analysisUnderstanding Clang AST nodesUnderstanding the parser actions with a debuggerExercising a parser errorWriting code that traverses the Clang ASTSerializing the AST with precompiled headersSemantic analysisExercising a semantic errorGenerating the LLVM IR code
OverviewUnderstanding the LLVM IR target dependency
Introducing the LLVM IR in-memory model
Building and running the IR generatorLearning how to write code to generate any IR construct with the C++ backend
Compile-time and link-time optimizationsDiscovering which passes matterUnderstanding pass dependenciesUnderstanding the pass APIWriting a custom passBuilding and running your new pass with the LLVM build systemBuilding and running your new pass with your own Makefile
OverviewUsing the backend tools
The languageKnowing the code generator .td filesTarget propertiesRegistersInstructions
The SelectionDAG classLoweringDAG combine and legalizationDAG-to-DAG instruction selectionPattern matchingVisualizing the instruction selection processFast instruction selection
Instruction itinerariesHazard detectionScheduling units
Register coalescerVirtual register rewriteTarget hooks
Frame indexes
MC instructionsCode emission
Getting to know the LLVM JIT engine basicsIntroducing the execution engineMemory management
Writing blobs to memoryUsing JITMemoryManagerTarget code emittersTarget informationLearning how to use the JIT classThe generic value
The MCJIT engineLearning the module's statesUnderstanding how MCJIT compiles modulesThe Object buffer, the cache, and the imageDynamic linkingThe memory managerThe MC code emissionObject finalizationUsing the MCJIT engine
Using the lli toolUsing the llvm-rtdyld tool
Comparing GCC and LLVM
Standard C and C++ librariesRuntime librariesThe assembler and the linkerThe Clang frontendMultilib
Driver options for the targetDependenciesCross-compilingInstalling GCCPotential problemsChanging the system root
Configuration optionsBuilding and installing your Clang-based cross-compilerAlternative build methodsNinjaELLCCEmbToolkit
Development boardsSimulators
Understanding the role of a static analyzerComparing classic warnings versus the Clang Static AnalyzerThe power of the symbolic execution engine
Using the driver versus using the compilerGetting to know the available checkersUsing the static analyzer in the Xcode IDEGenerating graphical reports in HTMLHandling large projectsA real-world example – finding bugs in Apache
Getting familiar with the project architectureWriting your own checkerSolving the problem with a custom checkerWriting the state classUnderstanding ProgramState immutabilityDissecting the codeDefining the Checker subclassWriting the Register macroImplementing the Checker subclassAdding registration codeBuilding and testing
Generating a compile command database
Using clang-tidy to check your code
Clang ModernizerClang Apply ReplacementsClangFormatModularizeUnderstanding C/C++ APIs' DefinitionsThe linker jobThe frontend counterpartProblems of relying on the C/C++ preprocessorUnderstanding the working of modulesUsing modulesUnderstanding ModularizeUsing ModularizeModule Map CheckerPPTraceClang QueryClang CheckRemove c_str() calls
Problem definition – writing a C++ code refactoring toolConfiguring your source code locationDissecting tooling boilerplate codeUsing AST matchersComposing matchersPutting the AST matcher predicates in the codeWriting the callbacksTesting your new refactoring tool

Overview

Dive into the world of LLVM with this comprehensive guide! 'Getting Started with LLVM Core Libraries' helps you master the foundational tools and techniques of the LLVM infrastructure, enabling you to build and optimize advanced compiler technologies and tools. From source code processing to executing LLVM IR, this book provides everything you need.

What this Book will help me do

Configure and install LLVM and associated projects to set up an efficient development environment.
Gain a deep understanding of LLVM's architecture and library interactions for tool development.
Learn the intricacies of source code processing, including lexing, parsing, and code analysis.
Develop and transform LLVM Intermediate Representation (IR) code and perform custom analyses.
Utilize Clang's development capabilities, such as writing JIT optimized tools and plugins.

Author(s)

Bruno Lopes and None Auler bring years of expertise in software engineering and compiler development to this book. They have a deep technical understanding of the LLVM toolchain, with practical experience in designing and utilizing these technologies directly. Their teaching approach combines clear explanation of concepts with practical examples drawn from real-world scenarios.

Who is it for?

This book is perfect for developers, engineers, and computer science enthusiasts who are looking to explore or deepen their understanding of LLVM. Suitable for individuals with basic programming knowledge and an interest in system or compiler-level development. If your goal is mastering compiler design or tool development using LLVM, this book will guide you effectively.