Toolchains

GNU Toolchain

• GCC - The GNU Compiler Collection (Git)
• GDB - The GNU Project Debugger (Git)
• Binutils - The GNU Binary Utilities (Git)

LLVM Toolchain

• LLVM - The LLVM Compiler Infrastructure (Git)
• LLDB - The LLDB Debugger
• Clang - C language family frontend for LLVM
• LLD - The LLVM Linker

GNU Toolchain Resources

• Binutils Porting Guide To A New Target/Processor Architecture
• How To Retarget the GNU Toolchain in 21 Patches
• GCC under the hood
• Everything I know about GNU toolchain
• The Architecture of Open Source Applications (Volume 2): GDB
• GCC profiler internals
• GCC for New Contributors
• GCC Wiki
• GNU Toolchain sourceware buildbot
• Writing a GCC plugin in Python
• Verifying GCC optimizations using an SMT solver

LLVM Resources

• The Architecture of Open Source Applications: LLVM
• LLVM for Grad Students
• Creating an LLVM Backend for the Cpu0 Architecture
• Let's Work on an LLVM Superoptimizer
• Souper - Superoptimizer for LLVM IR
• clang-tutor - A collection of out-of-tree Clang plugins for teaching and learning
• llvm-tutor - A collection of out-of-tree LLVM passes for teaching and learning
• A Tourist's Guide to the LLVM Source Code
• LLD from a user's perspective
• What makes LLD so fast?
• The LLVM Lexicon
• LLVM internals, part 1: the bitcode format
• LLVM internals, part 2: parsing the bitstream
• LLVM internals, part 3: from bitcode to IR
• LLVM internals, part 4: attributes and attribute groups
• LLVM Passes for Security 101: A Brief Introduction (Part 1/4)
• LLVM Passes for Security 101: Static Analysis (Part 2/4)
• LLVM Passes for Security 101: Our First Transformation Pass (Part 3/4)
• LLVM Passes for Security 101: Passes for Fuzzing (Part 4/4)
• Lanai, the mystery CPU architecture in LLVM
• Compilers and IRs: LLVM IR, SPIR-V, and MLIR

Cross toolchains

• Crosstool-NG - Versatile toolchain generator supporting many architectures and components
• OSXCross - macOS Cross toolchain for Linux and *BSD

ELF

• Executable and Linking Format (ELF) Specification Version 1.1 (PDF)
• Executable and Linking Format (ELF) Specification Version 1.2 (PDF)
• ELF for the Arm Architecture
• ELF for the Arm 64-bit Architecture (AArch64)
• LSB 5: Executable And Linking Format (ELF)
• elf(5) - Format of Executable and Linking Format (ELF) files
• NetBSD vendor-specific ELF Note Elements
• How programs get run: ELF binaries
• ELF's Linker's and other magical creatures
• ELF: symbol lookup via DT_HASH
• ELF: better symbol lookup via DT_GNU_HASH
• How to execute an object file: Part 1
• How to execute an object file: Part 2
• How to execute an object file: Part 3
• About ELF Auxiliary Vectors
• The Missing Link: Explaining ELF Static Linking, Semantically
• The Cost Of ELF Symbol Hashing
• Executable shared ELF files
• ELF introspection, robustly and portably
• ELF dynamic linking: a brief introduction
• ELF Tool Chain Project
• PatchELF - A simple utility for modifying existing ELF executables and libraries
• elfcat - ELF visualizer, generates HTML files from ELF binaries
• gwcheck - Check .gnu.warning.* sections in ELF object files

Mach-O

• Overview of the Mach-O Executable Format
• OS X ABI Mach-O File Format Reference
• Embedded Bitcode

Debuggers

• How Debuggers Work: Getting and Setting x86 Registers, Part 1
• How Debuggers Work: Getting and Setting x86 Registers, Part 2: XSAVE
• Compressed debug sections
• Distribution of debug information

DWARF

• DWARF Debugging Standard
• DWARF Debugging Information Format Version 5 (PDF)
• Introduction to the DWARF Debugging Format (PDF)
• DWARF for the Arm Architecture
• DWARF for the Arm 64-bit Architecture (AArch64)

Linkers

• Linkers and Loaders (Mirror)
• Beginner's Guide to Linkers
• Linkers part 1 - Introduction
• Linkers part 2 - Technical introduction
• Linkers part 3 - Continuing notes on linkers
• Linkers part 4 - Shared Libraries
• Linkers part 5 - Shared Libraries Redux
• Linkers part 6 - Relocations
• Linkers part 7 - Thread Local Storage
• Linkers part 8 - ELF Segments and Sections
• Linkers part 9 - Symbol Versions and Relaxation
• Linkers part 10 - Parallel Linking
• Linkers part 11 - Archives
• Linkers part 12 - Symbol Resolution
• Linkers part 13 - Symbol Versions Redux
• Linkers part 14 - Link Time Optimization, Initialization Code
• Linkers part 15 - COMDAT sections
• Linkers part 16 - C++ Template Instantiation, Exception Frames
• Linkers part 17 - Warning Symbols
• Linkers part 18 - Incremental Linking
• Linkers part 19 - __start/__stop Symbols, Byte Swapping
• Linkers part 20 - A short update on gold
• All about symbol versioning
• All about thread-local storage
• All about Global Offset Table
• All about Procedure Linkage Table
• All about COMMON symbols
• Explain GNU style linker options
• LLD and GNU linker incompatibilities
• Copy relocations, canonical PLT entries and protected visibility
• Metadata sections, COMDAT and SHF_LINK_ORDER
• Linker garbage collection
• The dark side of RISC-V linker relaxation
• Weak symbol
• ELF interposition and -Bsymbolic
• -fno-semantic-interposition
• Dependency related linker options
• Symbol processing
• SECTIONS and OVERWRITE_SECTIONS
• COMDAT and section group
• Extract an archive member to satisfy a DSO undef
• Relative relocations and RELR
• .init, .ctors, and .init_array
• Archives and –start-lib
• Analysis and introspection options in linkers
• Mold - A Modern Linker
• Linkers and Libraries Guide
• A New ELF Linker (GNU Gold)
• Relocations: fantastic symbols, but where to find them?
• Your own linker warnings using the GNU toolchain
• Why symbol visibility is good
• Everything You Never Wanted To Know About Linker Script
• Load-time relocation of shared libraries
• Position Independent Code (PIC) in shared libraries
• Position Independent Code (PIC) in shared libraries on x64
• RISC-V linker relaxation in lld
• How and why to do link-time symbol wrapping (or not?)
• Relocatable linking

Security

• All about sanitizer interceptors
• Control-flow integrity

Tutorials

• Demystifying programs that create programs, part 1: A disassembler
• Demystifying programs that create programs, part 2: Starting an assembler
• Demystifying programs that create programs, part 3: Globals, passes, and error handling
• Demystifying programs that create programs, part 4: Parsing
• Demystifying programs that create programs, part 5: Processing our first opcode
• Demystifying programs that create programs, part 6: Processing more opcodes
• Demystifying programs that create programs, part 7: Further opcode processing
• Demystifying programs that create programs, part 8: Finishing opcode processing
• Demystifying programs that create programs, part 9: Pseudo-ops