book

Getting started with LLVM core libraries

Name: Getting started with LLVM core libraries
ISBN: 9781782166924

by Bruno Lopes, Rafael Auler

August 2014

Beginner to intermediate

314 pages

7h 57m

English

Packt Publishing

Read now

Unlock full access

Getting Started with LLVM Core Libraries
Table of Contents
Getting Started with LLVM Core Libraries
Credits
About the Authors
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers, and moreWhy subscribe?Free access for Packt account holders
Preface
What this book covers
What you need for this book
Who this book is for

Conventions
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions
1. Build and Install LLVM
Understanding LLVM versions
Obtaining prebuilt packages
Obtaining the official prebuilt binariesUsing package managersStaying updated with snapshot packagesLinuxWindows
Building from sources
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
Summary
2. External Projects
Introducing Clang extrasBuilding and installing Clang extra toolsUnderstanding Compiler-RTSeeing Compiler-RT in action
Using the DragonEgg plugin
Building DragonEggUnderstanding the compilation pipeline with DragonEgg and LLVM toolsUnderstanding the LLVM test suiteUsing LLDBExercising a debug session with LLDBIntroducing the libc++ standard library
Summary
3. Tools and Design
Introducing LLVM's basic design principles and its history
Understanding LLVM today
Interacting with the compiler driver
Using standalone tools
Delving into the LLVM internal design
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 your first LLVM project
Writing the MakefileWriting the code
Navigating the LLVM source – general advice
Understanding the code as a documentationAsking the community for helpCoping with updates – using the SVN log as a documentationConcluding remarks
Summary
4. The Frontend
Introducing ClangFrontend actionsLibrariesUsing libclangUnderstanding Clang diagnosticsReading diagnostics
Learning the frontend phases with Clang
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
Putting it together
Summary
5. The LLVM Intermediate Representation
OverviewUnderstanding the LLVM IR target dependency
Exercising basic tools to manipulate the IR formats
Introducing the LLVM IR language syntax
Introducing the LLVM IR in-memory model
Writing a custom LLVM IR generator
Building and running the IR generatorLearning how to write code to generate any IR construct with the C++ backend
Optimizing at the IR level
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
Summary
6. The Backend
OverviewUsing the backend tools
Learning the backend code structure
Knowing the backend libraries
Learning how to use TableGen for LLVM backends
The languageKnowing the code generator .td filesTarget propertiesRegistersInstructions
Understanding the instruction selection phase
The SelectionDAG classLoweringDAG combine and legalizationDAG-to-DAG instruction selectionPattern matchingVisualizing the instruction selection processFast instruction selection
Scheduler
Instruction itinerariesHazard detectionScheduling units
Machine instructions
Register allocation
Register coalescerVirtual register rewriteTarget hooks
Prologue and epilogue
Frame indexes
Understanding the machine code framework
MC instructionsCode emission
Writing your own machine pass
Summary
7. The Just-in-Time Compiler
Getting to know the LLVM JIT engine basicsIntroducing the execution engineMemory management
Introducing the llvm::JIT framework
Writing blobs to memoryUsing JITMemoryManagerTarget code emittersTarget informationLearning how to use the JIT classThe generic value
Introducing the llvm::MCJIT framework
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 LLVM JIT compilation tools
Using the lli toolUsing the llvm-rtdyld tool
Other resources
Summary
8. Cross-platform Compilation
Comparing GCC and LLVM
Understanding target triples
Preparing your toolchain
Standard C and C++ librariesRuntime librariesThe assembler and the linkerThe Clang frontendMultilib
Cross-compiling with Clang command-line arguments
Driver options for the targetDependenciesCross-compilingInstalling GCCPotential problemsChanging the system root
Generating a Clang cross-compiler
Configuration optionsBuilding and installing your Clang-based cross-compilerAlternative build methodsNinjaELLCCEmbToolkit
Testing
Development boardsSimulators
Additional resources
Summary
9. The Clang Static Analyzer
Understanding the role of a static analyzerComparing classic warnings versus the Clang Static AnalyzerThe power of the symbolic execution engine
Testing the static analyzer
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
Extending the static analyzer with your own checkers
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
More resources
Summary
10. Clang Tools with LibTooling
Generating a compile command database
The clang-tidy tool
Using clang-tidy to check your code
Refactoring tools
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
Writing your own tool
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
More resources
Summary
Index

Content preview from Getting started with LLVM core libraries

Chapter 9. The Clang Static Analyzer

Humans show difficulty in planning the construction of an abstract apparatus for which they cannot easily measure the size of and quantify effort. Not surprisingly, software projects show a remarkable history of failures owing to an unhandled increase in complexity. If building complex software requires an unusual amount of coordination and organization, maintaining it is perhaps an even tougher challenge.

Still, the older the software gets, the harder it becomes to maintain. It typically reflects the effort of different generations of programmers with contrasting views. When a new programmer is in charge of maintaining old software, it is common practice to simply tightly wrap unintelligible old code pieces, ...

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: 9781782166924

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Getting started with LLVM core libraries

by Bruno Lopes, Rafael Auler

Chapter 9. The Clang Static Analyzer

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.