Index
A
- --analyze flag / Using the driver versus using the compiler
- Abstract Syntax Tree (AST)
- alternative build methods, LLVM/Clang-based toolchains
- about / Alternative build methods
- Ninja / Ninja
- ELLCC / ELLCC
- EmbToolkit / EmbToolkit
- analyzer-checker flag / Getting to know the available checkers
- ARM cross-compiler / Understanding target triples
- AST matchers
- using / Using AST matchers
- URL, for documentation / Using AST matchers
- composing / Composing matchers
- predicates, adding / Putting the AST matcher predicates in the code
- autotools-generated configure script
- used, for building LLVM / Using the autotools-generated configure script
- --enable-optimized option / Using the autotools-generated configure script
- --enable-assertions option / Using the autotools-generated configure script
- --enable-shared option / Using the autotools-generated configure script
- --enable-jit option / Using the autotools-generated configure script
- --prefix option / Using the autotools-generated configure script
- --enable-targets option / Using the autotools-generated configure script
B
- backend
- code structure / Learning the backend code structure
- implementing, TableGen used / Learning how to use TableGen for LLVM backends
- backend libraries
- about / Knowing the backend libraries
- target-dependent libraries / Knowing the backend libraries
- target-independent libraries / Knowing the backend libraries
- BasicBlockPass
- about / Understanding the pass API
- basic blocks (BBs) / Introducing the LLVM IR language syntax
- Beagle Board
- URL / Development boards
- bitcode
- about / Introducing Clang extras
- BuildMI() method / Target hooks
C
- C++ backend
- used, for generating IR construct / Learning how to write code to generate any IR construct with the C++ backend
- about / Learning how to write code to generate any IR construct with the C++ backend
- C++ programming practices
- polymorphism / Seeing polymorphism in practice
- templates, using / Introducing C++ templates in LLVM
- enforcing, in LLVM / Enforcing C++ best practices in LLVM
- URL / Enforcing C++ best practices in LLVM
- string references, creating in LLVM / Making string references lightweight in LLVM
- C/C++ API
- defining / Understanding C/C++ APIs' Definitions
- linker job / The linker job
- frontend counterpart / The frontend counterpart
- C/C++ preprocessor
- Canadian cross-compiler / Understanding target triples
- checkers
- about / Understanding the role of a static analyzer
- static analyzer, testing with / Getting to know the available checkers
- Clang
- about / Introducing Clang extras
- Check / Introducing Clang extras
- Format / Introducing Clang extras
- Compiler-RT / Understanding Compiler-RT
- URL / Introducing Clang
- frontend phases / Learning the frontend phases with Clang
- tools / The clang-tidy tool
- clang$$preprocessor
- URL, for documentation / PPTrace
- Clang-based cross-compiler
- clang -cc1 tool / Frontend actions
- clang-tidy tool
- about / The clang-tidy tool
- using / Using clang-tidy to check your code
- clang-tools-extra repository
- Clang Apply Replacements
- about / Clang Apply Replacements
- Clang AST nodes
- overview / Understanding Clang AST nodes
- Clang Check
- about / Introducing Clang extras, Clang Check
- Clang cross-compiler, generating
- about / Generating a Clang cross-compiler
- configuration options / Configuration options
- Clang diagnostics
- about / Understanding Clang diagnostics
- reading / Reading diagnostics
- Clang doxygen
- URL, for documentation / More resources
- Clang Format
- about / Introducing Clang extras
- ClangFormat
- about / ClangFormat
- Clang Front End Developer List
- Clang Modernizer
- about / Introducing Clang extras, Clang Modernizer
- Clang project
- about / Introducing Clang
- frontend actions / Frontend actions
- libraries / Libraries
- Clang Query
- about / Clang Query
- Clang Tidy
- about / Introducing Clang extras
- clang_visitChildren() function / Writing code that traverses the Clang AST
- classic warnings
- versus, static analyzer / Comparing classic warnings versus the Clang Static Analyzer
- cl namespace
- CMake
- URL / Using CMake and Ninja
- used, for building LLVM / Using CMake and Ninja
- used, for building LLVM with Unix / Building with Unix using CMake and Ninja
- build errors, solving for LLVM / Solving build errors
- code
- writing, for generating IR construct with C++ backend / Learning how to write code to generate any IR construct with the C++ backend
- code emission
- about / Overview, Code emission
- CodeGen directory
- code generator .td files
- about / Knowing the code generator .td files
- <Target>.td file / Target properties
- <Target>RegisterInfo.td file / Registers
- <Target>InstrFormats.td file / Instructions
- <Target>InstrInfo.td file / Instructions
- code generator phases
- code structure, backend
- compilation, DragonEgg
- with LLVM tools / Understanding the compilation pipeline with DragonEgg and LLVM tools
- compile command database
- generating / Generating a compile command database
- compiler
- about / Preparing your toolchain
- Compiler-RT
- about / Understanding Compiler-RT
- working with / Seeing Compiler-RT in action
- Compiler-RT Version 3.4
- URL, for downloading / Understanding Compiler-RT
- compiler driver
- about / Interacting with the compiler driver
- interacting with / Interacting with the compiler driver
- configuration options, cross-compiler generation
- --target / Configuration options
- --enable-targets / Configuration options
- --with-c-include-dirs / Configuration options
- --with-gcc-toolchain / Configuration options
- --with-default-sysroot / Configuration options
- control flow graph (CFG) / Writing code that traverses the Clang AST
- copyPhysReg() method / Target hooks
- cross-compilation, testing
- about / Testing
- development boards / Development boards
- simulators / Simulators
- cross compiling, with Clang command-line arguments
- about / Cross-compiling with Clang command-line arguments, Cross-compiling
- driver options, for target / Driver options for the target
- dependencies / Dependencies
- GCC installation / Installing GCC
- potential issues / Potential problems
- system root, modifying / Changing the system root
- Cross Linux, from Scratch tutorials
- URL / Dependencies
- custom checkers
- static analyzer, extending wtih / Extending the static analyzer with your own checkers
- writing / Writing your own checker
- implementing / Solving the problem with a custom checker
- state class, creating / Writing the state class
- Checker subclass, defining / Defining the Checker subclass
- Register macro, writing / Writing the Register macro
- Checker subclass, implementing / Implementing the Checker subclass
- registration code, adding / Adding registration code
- building / Building and testing
- testing / Building and testing
- URL, for developing / More resources
- URL, for building / More resources
- custom LLVM IR generator
- writing / Writing a custom LLVM IR generator
- header files / Writing a custom LLVM IR generator
- custom Makefile
- used, for building pass / Building and running your new pass with your own Makefile
- used, for running pass / Building and running your new pass with your own Makefile
- custom pass
- writing / Writing a custom pass
- building, with LLVM build system / Building and running your new pass with the LLVM build system
- running, with LLVM build system / Building and running your new pass with the LLVM build system
- running, with custom Makefile / Building and running your new pass with your own Makefile
- building, with custom Makefile / Building and running your new pass with your own Makefile
- custom tool
- creating / Writing your own tool
- C++ code refactoring tool, creating / Problem definition – writing a C++ code refactoring tool
- source code location, configuring / Configuring your source code location
- boilerplate code, dissecting / Dissecting tooling boilerplate code
- AST matchers, using / Using AST matchers
- callbacks, defining / Writing the callbacks
- C++ code refactoring tool, testing / Testing your new refactoring tool
D
- dag
- about / Instructions
- DAG-to-DAG instruction selection
- about / DAG-to-DAG instruction selection
- pattern matching / Pattern matching
- DAG combine
- about / DAG combine and legalization
- DAG legalization
- about / DAG combine and legalization
- debug session
- exercising, LLDB used / Exercising a debug session with LLDB
- default values, configure script flags
- CMAKE_BUILD_TYPE / Using CMake and Ninja
- CMAKE_ENABLE_ASSERTIONS / Using CMake and Ninja
- BUILD_SHARED_LIBS / Using CMake and Ninja
- CMAKE_INSTALL_PREFIX / Using CMake and Ninja
- LLVM_TARGETS_TO_BUILD / Using CMake and Ninja
- design principles, LLVM / Introducing LLVM's basic design principles and its history
- development boards
- Panda Board / Development boards
- Beagle Board / Development boards
- SEAD-3 / Development boards
- Carambola-2 / Development boards
- directed acyclic graph (DAG)
- about / Overview
- Directed Acyclic Graph (DAG)
- Dominator Tree
- about / Understanding pass dependencies
- DragonEgg
- using / Using the DragonEgg plugin
- URL / Using the DragonEgg plugin
- building / Building DragonEgg
- installing / Building DragonEgg
- compiling, with LLVM tools / Understanding the compilation pipeline with DragonEgg and LLVM tools
- LLVM test suite / Understanding the LLVM test suite
- LLDB, using / Using LLDB
- driver
- used, for testing static analyzer / Using the driver versus using the compiler
- dynamic linking, MCJIT engine
- about / Dynamic linking
- dynamic shared object (DSO)
- about / Introducing the execution engine
E
- ELLCC
- EmbToolkit
- about / EmbToolkit
- URL / EmbToolkit
- emitWord() method
- about / Target code emitters
- epilogue
- about / Prologue and epilogue
- Executable Format / The linker job
- execution engine
- about / Introducing the execution engine
- lazy compilation / Introducing the execution engine
- external global variables, compilation / Introducing the execution engine
- lookup, for external symbols / Introducing the execution engine
- symbol resolution, for external symbols / Introducing the execution engine
- ExecutionEngine class
- about / Introducing the execution engine
- explicit dependency
- about / Understanding pass dependencies
- ExplodedGraph / Getting familiar with the project architecture
- exponential-time complexity
F
- fast instruction selection
- about / Fast instruction selection
- first LLVM project
- writing / Writing your first LLVM project
- Makefile, writing / Writing the Makefile
- coding / Writing the code
- frame indexes
- about / Frame indexes
- frontend
- used, for testing static analyzer / Using the driver versus using the compiler
- frontend actions, Clang
- about / Frontend actions
- ASTView / Frontend actions
- EmitBC / Frontend actions
- EmitObj / Frontend actions
- FixIt / Frontend actions
- PluginAction / Frontend actions
- RunAnalysis / Frontend actions
- frontend phases, Clang
- about / Learning the frontend phases with Clang
- lexical analysis / Lexical analysis
- syntactic analysis / Syntactic analysis
- semantic analysis / Semantic analysis
- LLVM IR code, generating / Generating the LLVM IR code
- implementing / Putting it together
- FTL component
- Function**Create() static method / Writing a custom LLVM IR generator
- FunctionPass
- about / Understanding the pass API
G
- GCC
- versus LLVM / Comparing GCC and LLVM
- getPointerToFunction() method
- about / The generic value
- Git mirror repository
- sources, obtaining from / Git
- Graphviz package
H
- hazard detection
- about / Hazard detection
- header files, custom LLVM IR generator
- #include <llvm/ADT/SmallVector.h> / Writing a custom LLVM IR generator
- #include <llvm/Analysis/Verifier.h> / Writing a custom LLVM IR generator
- #include <llvm/IR/BasicBlock.h> / Writing a custom LLVM IR generator
- #include <llvm/IR/CallingConv.h> / Writing a custom LLVM IR generator
- #include <llvm/IR/Function.h> / Writing a custom LLVM IR generator
- #include <llvm/IR/Instructions.h> / Writing a custom LLVM IR generator
- #include <llvm/IR/LLVMContext.h> / Writing a custom LLVM IR generator
- #include <llvm/IR/Module.h> / Writing a custom LLVM IR generator
- #include <llvm/Bitcode/ReaderWriter.h> / Writing a custom LLVM IR generator
- #include <llvm/Support/ToolOutputFile.h> / Writing a custom LLVM IR generator
- HTML
- graphical reports, generating in / Generating graphical reports in HTML
I
- implicit dependency
- about / Understanding pass dependencies
- Industry Standard Architecture (ISA)
- infrastructure, LLVM project
- frontend / Understanding LLVM today
- IR / Understanding LLVM today
- backend / Understanding LLVM today
- InitializeNativeTarget() method
- installation, Clang-based cross-compiler / Building and installing your Clang-based cross-compiler
- installation, clang-tools-extra repository tools / Building and installing Clang extra tools
- installation, DragonEgg / Building DragonEgg
- installation, LLVM
- prebuilt packages, using / Obtaining prebuilt packages
- package managers, using / Using package managers
- instruction itineraries
- about / Instruction itineraries
- instruction scheduling
- instruction selection
- about / Overview, Understanding the instruction selection phase
- SelectionDAG class / The SelectionDAG class
- lowering / Lowering
- DAG combine / DAG combine and legalization
- DAG legalization / DAG combine and legalization
- DAG-to-DAG instruction selection / DAG-to-DAG instruction selection
- visualizing / Visualizing the instruction selection process
- fast instruction selection / Fast instruction selection
- interaction, compiler
- in memory / Understanding LLVM today
- through files / Understanding LLVM today
- International Obfuscated C Code Contest (IOCCC) / Preprocessing, ClangFormat
- IR
- about / Introducing LLVM's basic design principles and its history
- transforming, to assembly code / Overview
- IR construct
- generating, with C++ backend / Learning how to write code to generate any IR construct with the C++ backend
- IR formats
- manipulating, with basic tools / Exercising basic tools to manipulate the IR formats
- IR generator
- building / Building and running the IR generator
- running / Building and running the IR generator
- IR level optimization
- about / Optimizing at the IR level
- compile-time optimization / Compile-time and link-time optimizations
- link-time optimization / Compile-time and link-time optimizations
- passes / Discovering which passes matter
- pass dependencies / Understanding pass dependencies
- pass API / Understanding the pass API
- custom pass, writing / Writing a custom pass
- isLoadFromStackSlot() method / Target hooks
- isStoreToStackSlot() method / Target hooks
J
- JIT class
- about / Introducing the llvm::JIT framework
- using / Learning how to use the JIT class
- generic value / The generic value
- JITCodeEmitter class
- about / Writing blobs to memory
- JIT compilation cost analysis
- URL, for technical report / Understanding the instruction selection phase
- JIT compiler
- overview / Getting to know the LLVM JIT engine basics
- execution engine / Introducing the execution engine
- memory management / Memory management
- tools / Using LLVM JIT compilation tools
- other resources / Other resources
- JITMemoryManager class
- using / Using JITMemoryManager
- Just-In-Time Compilation / Using the autotools-generated configure script
L
- large projects, static analyzer
- handling / Handling large projects
- real-world example / A real-world example – finding bugs in Apache
- URL, for real-world example / A real-world example – finding bugs in Apache
- lazy compilation
- about / Introducing the execution engine
- lexical analysis
- about / Lexical analysis
- lexical errors, exercising / Exercising lexical errors
- libclang code, writing / Writing libclang code that uses the lexer
- preprocessing / Preprocessing
- libc++
- libc++ standard library
- libClang
- libclang
- URL / Libraries
- using / Using libclang
- libclangAnalysis
- libclangAST
- about / Libraries
- libclangBasic
- about / Libraries
- libclangCodeGen
- about / Libraries
- libclangDriver
- libclangLex
- about / Libraries
- libclangParse
- about / Libraries
- libclangRewrite
- about / Libraries
- libclangSema
- about / Libraries
- libLLVMAnalysis
- libLLVMCodeGen
- libLLVMCore
- libLLVMSupport
- libLLVMTarget
- libLLVMX86CodeGen
- libraries
- about / Getting to know LLVM's basic libraries
- libLLVMCore / Getting to know LLVM's basic libraries
- libLLVMAnalysis / Getting to know LLVM's basic libraries
- libLLVMCodeGen / Getting to know LLVM's basic libraries
- libLLVMTarget / Getting to know LLVM's basic libraries
- libLLVMX86CodeGen / Getting to know LLVM's basic libraries
- libLLVMSupport / Getting to know LLVM's basic libraries
- libClang / Getting to know LLVM's basic libraries
- libclangDriver / Getting to know LLVM's basic libraries
- libclangAnalysis / Getting to know LLVM's basic libraries
- URL / Getting to know LLVM's basic libraries
- libraries, Clang
- Linkable Format / The linker job
- llc tool / Using standalone tools
- lld
- LLDB
- using / Using LLDB
- URL / Using LLDB
- used, for exercising debug session / Exercising a debug session with LLDB
- lli tool / Using standalone tools
- about / Using LLVM JIT compilation tools
- using / Using the lli tool
- LLVM
- installing, prebuilt packages used / Obtaining prebuilt packages
- installing, package managers used / Using package managers
- building, from sources / Building from sources
- system requisites, for compiling / System requirements
- building / Building and installing LLVM
- installing / Building and installing LLVM
- building, autotools-generated configure script used / Using the autotools-generated configure script
- building, Unix used / Building and configuring with Unix
- building, CMake used / Using CMake and Ninja
- building, Ninja used / Using CMake and Ninja
- building with Unix, Ninja used / Using CMake and Ninja, Building with Unix using CMake and Ninja
- building with Unix, CMake used / Building with Unix using CMake and Ninja
- building, other Unix approaches used / Using other Unix approaches
- compiling, on Microsoft Visual Studio / Windows and Microsoft Visual Studio
- compiling, on Windows / Windows and Microsoft Visual Studio
- history / Introducing LLVM's basic design principles and its history
- design principles / Introducing LLVM's basic design principles and its history
- URL, for frontend tutorial / Generating the LLVM IR code
- versus GCC / Comparing GCC and LLVM
- URL, for documentation / Ninja
- llvm$$Function class
- URL, for documentation / Writing the code
- llvm$$JIT framework
- about / Introducing the llvm::JIT framework
- blobs, writing to memory / Writing blobs to memory
- JITMemoryManager class, using / Using JITMemoryManager
- target code emitters / Target code emitters
- target information / Target information
- JIT class / Learning how to use the JIT class
- llvm$$MCJIT framework
- about / Introducing the llvm::MCJIT framework
- MCJIT engine / The MCJIT engine
- MCJIT engine, compiling modules / Understanding how MCJIT compiles modules
- MCJIT engine, using / Using the MCJIT engine
- URL, for design and implementation / Other resources
- llvm-as tool / Using standalone tools
- LLVM-based compiler
- about / Understanding LLVM today
- llvm-config --libs shell command / Building and running your new pass with your own Makefile
- llvm-dis tool / Using standalone tools
- llvm-extract tool
- llvm-link tool / Using standalone tools
- llvm-mc tool / Using standalone tools
- llvm-rtdyld tool
- about / Using LLVM JIT compilation tools
- using / Using the llvm-rtdyld tool
- LLVM-supported platforms
- URL, for updated list / System requirements
- LLVM build system
- used, for building pass / Building and running your new pass with the LLVM build system
- used, for running pass / Building and running your new pass with the LLVM build system
- LLVM core
- LLVM core Developer List
- LLVMdev
- LLVM internal design
- delving into / Delving into the LLVM internal design
- libraries / Getting to know LLVM's basic libraries
- C++ programming practices / Introducing LLVM's C++ practices
- pluggable pass interface / Demonstrating the pluggable pass interface
- LLVM IR
- about / Introducing LLVM's basic design principles and its history, Understanding LLVM today
- basic principles / Introducing LLVM's basic design principles and its history
- overview / Overview
- basic tools, exercising for manipulating IR formats / Exercising basic tools to manipulate the IR formats
- bitcode format / Exercising basic tools to manipulate the IR formats
- assembly text format / Exercising basic tools to manipulate the IR formats
- fundamental properties / Introducing the LLVM IR language syntax
- LLVM IR in-memory model
- about / Introducing the LLVM IR in-memory model
- Module class / Introducing the LLVM IR in-memory model
- Function class / Introducing the LLVM IR in-memory model
- BasicBlock class / Introducing the LLVM IR in-memory model
- Instruction class / Introducing the LLVM IR in-memory model
- Value class / Introducing the LLVM IR in-memory model
- User class / Introducing the LLVM IR in-memory model
- LLVM IR language syntax
- LLVM IR target dependency
- LLVM kaleidoscope tutorial
- URL / Other resources
- LLVM libraries
- about / Understanding LLVM today
- LLVM project
- understanding / Understanding LLVM today
- infrastructure / Understanding LLVM today
- about / Overview
- LLVM project/infrastructure
- about / Understanding LLVM today
- LLVM projects
- LLVM core / Introducing Clang extras
- Clang / Introducing Clang extras
- LLVM source code
- navigating / Navigating the LLVM source – general advice
- documentation / Understanding the code as a documentation
- community, using for help / Asking the community for help
- updating, SVN log used / Coping with updates – using the SVN log as a documentation
- conclusion / Concluding remarks
- LLVM test suite
- LLVM Version 3.4
- about / Understanding LLVM versions
- LLVM versions
- about / Understanding LLVM versions
- loadRegFromStackSlot() method / Target hooks
- Loop Info
- about / Understanding pass dependencies
- lowering, instruction selection / Lowering
M
- -m32 flag
- about / Seeing Compiler-RT in action
- Machine Code (MC) framework / Writing blobs to memory
- MachineCodeEmitter class
- about / Writing blobs to memory
- allocateSpace() method / Writing blobs to memory
- emitWordBE() method / Writing blobs to memory
- emitByte() method / Writing blobs to memory
- emitWordLE() method / Writing blobs to memory
- emitAlignment() method / Writing blobs to memory
- machine instructions
- about / Machine instructions
- machine pass
- writing / Writing your own machine pass
- Mac OS X
- LLVM, compiling on / Mac OS X and Xcode
- Makefile
- writing / Writing the Makefile
- MC
- about / Understanding the machine code framework
- code emission / Code emission
- MC code emission
- about / The MC code emission
- MC directory
- MC instructions
- about / MC instructions
- MCJIT class
- MCJIT engine
- about / The MCJIT engine
- modules, states / Learning the module's states
- modules, compiling / Understanding how MCJIT compiles modules
- ObjectBuffer class / The Object buffer, the cache, and the image
- MemoryBuffer class / The Object buffer, the cache, and the image
- ObjectImage class / The Object buffer, the cache, and the image
- dynamic linking / Dynamic linking
- memory manager / The memory manager
- MC code emission / The MC code emission
- object finalization / Object finalization
- using / Using the MCJIT engine
- MemoryBuffer class
- memory management
- about / Memory management
- memory manager
- about / The memory manager
- Microsoft Visual Studio
- LLVM, compiling on / Windows and Microsoft Visual Studio
- Modularize
- about / Introducing Clang extras, Modularize
- C/C++ API, defining / Understanding C/C++ APIs' Definitions
- C/C++ preprocessor, problems / Problems of relying on the C/C++ preprocessor
- modules / Understanding the working of modules
- modules, using / Using modules
- working with / Understanding Modularize
- using / Using Modularize
- Module Map Checker
- about / Module Map Checker
- ModulePass
- about / Understanding the pass API
- modules
- added state / Learning the module's states
- loaded state / Learning the module's states
- finalized state / Learning the module's states
- compiling, by MCJIT engine / Understanding how MCJIT compiles modules
- working with / Understanding the working of modules
- using / Using modules
- Multilib
N
- Ninja
- URL / Using CMake and Ninja
- used, for building LLVM / Using CMake and Ninja
- used, for building LLVM with Unix / Building with Unix using CMake and Ninja
- build errors, solving for LLVM / Solving build errors
- about / Ninja
O
- ObjectBuffer class
- object finalization
- about / Object finalization
- ObjectImage class
- official binary distribution
- URL, for downloading / Windows and Microsoft Visual Studio, Mac OS X and Xcode
- official prebuilt binaries
- obtaining / Obtaining the official prebuilt binaries
- opt tool / Using standalone tools
- about / Understanding pass dependencies
P
- package managers
- using / Using package managers
- used, for installing LLVM / Using package managers
- snapshot packages, using / Staying updated with snapshot packages
- Panda Board
- URL / Development boards
- pass
- pass API
- about / Understanding the pass API
- pass dependencies, IR level optimization
- about / Understanding pass dependencies
- explicit dependency / Understanding pass dependencies
- implicit dependency / Understanding pass dependencies
- pass manager
- pass subclasses
- ModulePass / Understanding the pass API
- FunctionPass / Understanding the pass API
- BasicBlockPass / Understanding the pass API
- URL, for documentation / Understanding the pass API
- pluggable pass interface
- polymorphism
- about / Seeing polymorphism in practice
- Position Independent Code (PIC) libraries / Mac OS X and Xcode
- post-register allocation scheduling
- about / Overview
- PPTrace
- pre-register allocation scheduling
- about / Overview
- prebuilt packages
- obtaining / Obtaining prebuilt packages
- used, for installing LLVM / Obtaining prebuilt packages
- official prebuilt binaries, obtaining / Obtaining the official prebuilt binaries
- URL, for downloading / Obtaining the official prebuilt binaries
- package managers, using / Using package managers
- precompiled headers (PCH) / Reading diagnostics
- Programmer's Manual
- ProgramPoint / Getting familiar with the project architecture
- ProgramState / Getting familiar with the project architecture
- project, static analyzer
- architecture / Getting familiar with the project architecture
- URL / More resources
- prologue
- about / Prologue and epilogue
- frame indexes / Frame indexes
Q
- QEMU
- about / Simulators
- URL / Simulators
R
- refactoring tools
- about / Refactoring tools
- Clang Modernizer / Clang Modernizer
- Clang Apply Replacements / Clang Apply Replacements
- ClangFormat / ClangFormat
- Modularize / Modularize
- Module Map Checker / Module Map Checker
- PPTrace / PPTrace
- Clang Query / Clang Query
- Clang Check / Clang Check
- remove-cstr-calls tool / Remove c_str() calls
- register allocation
- about / Overview, Register allocation
- register coalescer / Register coalescer
- virtual register rewrite / Virtual register rewrite
- target hooks / Target hooks
- remove-cstr-calls tool
- about / Remove c_str() calls
- resources, Clang tools / More resources
- retargetable compilers
- about / Overview
- RTDyldMemoryManager class
- about / Memory management
- allocateCodeSection() method / Memory management
- allocateDataSection() method / Memory management
- getSymbolAddress() method / Memory management
- finalizeMemory() method / Memory management
- runFunction() method / The generic value
- RuntimeDyld dynamic linker
S
- Scan-build
- about / Handling large projects
- scheduler
- about / Scheduler
- instruction itineraries / Instruction itineraries
- hazard detection / Hazard detection
- scheduling units / Scheduling units
- scheduling units
- about / Scheduling units
- SCRAM() function / Writing your own checker
- SEAD-3
- URL / Development boards
- Select() method / Pattern matching
- SelectionDAG class
- about / The SelectionDAG class
- semantic analysis
- about / Semantic analysis
- semantic error, exercising / Exercising a semantic error
- setDataLayout() function / Writing a custom LLVM IR generator
- setTargetTriple() function / Writing a custom LLVM IR generator
- simulators
- about / Simulators
- snapshot packages
- sources
- LLVM, building from / Building from sources
- obtaining / Obtaining sources
- URL, for downloading / Obtaining sources
- obtaining, from SVN repository / SVN
- obtaining, from Git mirror repository / Git
- ssl_cmd_verify_parse() function / A real-world example – finding bugs in Apache
- standalone tools
- using / Using standalone tools
- opt / Using standalone tools
- llc / Using standalone tools
- llvm-mc / Using standalone tools
- lli / Using standalone tools
- llvm-link / Using standalone tools
- llvm-as / Using standalone tools
- llvm-dis / Using standalone tools
- state class, custom checkers
- ProgramState, creating as immutable / Understanding ProgramState immutability
- code, examining / Dissecting the code
- static analyzer
- about / Understanding the role of a static analyzer
- versus, classic warnings / Comparing classic warnings versus the Clang Static Analyzer
- testing / Testing the static analyzer
- testing, driver used / Using the driver versus using the compiler
- testing, frontend used / Using the driver versus using the compiler
- testing, with checkers / Getting to know the available checkers
- using, in Xcode IDE / Using the static analyzer in the Xcode IDE
- graphical reports, generating in HTML / Generating graphical reports in HTML
- large projects, handling / Handling large projects
- extending, wtih custom checkers / Extending the static analyzer with your own checkers
- project, architecture / Getting familiar with the project architecture
- Static Single Assignment (SSA) form / Introducing the LLVM IR language syntax
- storeRegToStackSlot() method / Target hooks
- string references
- creating / Making string references lightweight in LLVM
- SVN repository
- symbolic execution engine
- syntactic analysis
- about / Syntactic analysis
- Clang AST nodes / Understanding Clang AST nodes
- parser actions, understanding with debugger / Understanding the parser actions with a debugger
- parser error, exercising / Exercising a parser error
- code, writing that traverses Clang AST / Writing code that traverses the Clang AST
- AST, serializing with precompiled headers / Serializing the AST with precompiled headers
- syntax-only flag / Getting to know the available checkers
- syscalls
- system requisites, LLVM
- for compiling / System requirements
T
- #0 tag / Introducing the LLVM IR language syntax
- <Target>.td file
- about / Target properties
- <Target>GenAsmMatcher.inc file
- about / Instructions
- <Target>GenAsmWriter.inc file
- about / Instructions
- <Target>GenCodeEmitter.inc file
- about / Instructions
- <Target>GenDAGISel.inc file
- about / Instructions
- <Target>GenDisassemblerTables.inc file
- about / Instructions
- <Target>GenInstrInfo.inc file
- about / Instructions
- <Target>InstrFormats.td file
- about / Instructions
- <Target>InstrInfo.td file
- about / Instructions
- <Target>InstrInfo class / Target hooks
- <Target>RegisterInfo.td file
- about / Registers
- TableGen
- about / Understanding Clang diagnostics
- used, for implementing backend / Learning how to use TableGen for LLVM backends
- working / The language
- URL / The language
- code generator .td files / Knowing the code generator .td files
- TableGen directory
- target-dependent libraries
- about / Knowing the backend libraries
- <Target>AsmParser.a / Knowing the backend libraries
- <Target>CodeGen.a / Knowing the backend libraries
- <Target>Desc.a / Knowing the backend libraries
- <Target>Disassembler.a / Knowing the backend libraries
- <Target>Info.a / Knowing the backend libraries
- target-independent libraries
- AsmParser.a / Knowing the backend libraries
- AsmPrinter.a / Knowing the backend libraries
- CodeGen.a / Knowing the backend libraries
- MC.a / Knowing the backend libraries
- MCDisassembler.a / Knowing the backend libraries
- MCJIT.a / Knowing the backend libraries
- MCParser.a / Knowing the backend libraries
- SelectionDAG.a / Knowing the backend libraries
- Target.a / Knowing the backend libraries
- target code emitters
- about / Target code emitters
- target datalayout construct / Introducing the LLVM IR language syntax
- Target folder
- target information
- about / Target information
- TargetJITInfo$$emitFunctionStub() method
- about / Target information
- TargetJITInfo$$relocate() method
- about / Target information
- TargetJITInfo$$replaceMachineCodeForFunction() method
- about / Target information
- TargetJITInfo class
- about / Target information
- TargetPassConfig class
- target triples
- overview / Understanding target triples
- toolchain, preparing
- about / Preparing your toolchain
- standard C and C++ libraries / Standard C and C++ libraries
- runtime libraries / Runtime libraries
- assembler / The assembler and the linker
- linker / The assembler and the linker
- frontend / The Clang frontend
- tools, backend
- llc tool / Using the backend tools
- tools, Clang
- clang-tidy tool / The clang-tidy tool
- refactoring tools / Refactoring tools
- resources / More resources
- tools, clang-tools-extra repository
- Clang Modernizer / Introducing Clang extras
- Clang Tidy / Introducing Clang extras
- Modularize / Introducing Clang extras
- PPTrace / Introducing Clang extras
- building / Building and installing Clang extra tools
- installing / Building and installing Clang extra tools
- tools, JIT compiler
- lli tool / Using LLVM JIT compilation tools, Using the lli tool
- llvm-rtdyld tool / Using LLVM JIT compilation tools, Using the llvm-rtdyld tool
- transformations, Clang Modernizer
- loop convert transform / Clang Modernizer
- use-nullptr transform / Clang Modernizer
- use-auto transform / Clang Modernizer
- add-override transform / Clang Modernizer
- pass-by-value transform / Clang Modernizer
- replace-auto_ptr transform / Clang Modernizer
- tree view / Windows and Microsoft Visual Studio
- turnReactorOn() function / Writing your own checker
U
- UND (undefined) / The linker job
- Unix
- used, for building LLVM / Building and configuring with Unix
V
W
- Windows
- LLVM, compiling on / Windows and Microsoft Visual Studio
- Windows installers
- URL, for downloading / Windows
X
- -Xanalyzer flag / Using the driver versus using the compiler
- Xcode
- LLVM, compiling on / Mac OS X and Xcode
- Xcode IDE
- static analyzer, using in / Using the static analyzer in the Xcode IDE