GCC Python plugin

Contents:

• Requirements
• Prebuilt-packages
• Building the plugin from source
  • Build-time dependencies
  • Building the code
• Basic usage of the plugin
  • Debugging your script
  • Accessing parameters
  • Adding new passes to the compiler
  • Wiring up callbacks
• Global data access
• Overview of GCC’s internals
• Example scripts
  • show-docs.py
  • show-passes.py
  • show-gimple.py
  • show-ssa.py
  • show-callgraph.py
• Working with C code
  • “Hello world”
  • Spell-checking string constants within source code
  • Finding global variables
• Locations
• Generating custom errors and warnings
• Working with functions and control flow graphs
• gcc.Tree and its subclasses
  • Blocks
  • Declarations
  • Types
  • Constants
  • Binary Expressions
  • Unary Expressions
  • Comparisons
  • References to storage
  • Other expression subclasses
  • Statements
  • SSA Names
• Gimple statements
• Optimization passes
  • Working with existing passes
  • Creating new optimization passes
  • Dumping per-pass information
• Working with callbacks
• Creating custom GCC attributes
  • Using the preprocessor to guard attribute usage
• Usage example: a static analysis tool for CPython extension code
  • gcc-with-cpychecker
  • Reference-count checking
  • Error-handling checking
  • Errors in exception-handling
  • Format string checking
  • Verification of PyMethodDef tables
  • Additional tests
  • Limitations and caveats
  • Ideas for future tests
  • Reusing this code for other projects
  • Common mistakes
• Success Stories
  • The GNU Debugger
  • LibreOffice
  • psycopg
  • pycups
  • python-krbV
  • Bugs found in itself
• Getting Involved
  • Ideas for using the plugin
  • Tour of the C code
  • Using the plugin to check itself
  • Test suite
  • Debugging the plugin’s C code
  • Patches
• Documentation
• Miscellanea
  • Interprocedural analysis (IPA)
  • Whole-program Analysis via Link-Time Optimization (LTO)
  • Inspecting GCC’s command-line options
  • Working with GCC’s tunable parameters
  • Working with the preprocessor
  • Version handling
  • Register Transfer Language (RTL)
• Release Notes
  • 0.17
  • 0.16
  • 0.15
  • 0.14
  • 0.13
  • 0.12
  • 0.11
  • 0.10
  • 0.9
  • 0.8
  • 0.7
• Appendices
  • All of GCC’s passes
  • gcc.Tree operators by symbol

This document describes the Python plugin I’ve written for GCC. In theory the plugin allows you to write Python scripts that can run inside GCC as it compiles code, exposing GCC’s internal data structures as a collection of Python classes and functions. The bulk of the document describes the Python API it exposes.

Hopefully this will be of use for writing domain-specific warnings, static analysers, and the like, and for rapid prototyping of new GCC features.

I’ve tried to stay close to GCC’s internal representation, but using classes. I hope that the resulting API is pleasant to work with.

The plugin is a work-in-progress; the API may well change.

Bear in mind that writing this plugin has been the first time I have worked with the insides of GCC. I have only wrapped the types I have needed, and within them, I’ve only wrapped properties that seemed useful to me. There may well be plenty of interesting class and properties for instances that can be added (patches most welcome!). I may also have misunderstood how things work.

Most of my development has been against Python 2 (2.7, actually), but I’ve tried to make the source code of the plugin buildable against both Python 2 and Python 3 (3.2), giving separate python2.so and python3.so plugins. (I suspect that it’s only possible to use one or the other within a particular invocation of “gcc”, due to awkward dynamic-linker symbol collisions between the two versions of Python).

The plugin is Free Software, licensed under the GPLv3 (or later).

Indices and tables

• Index
• Module Index
• Search Page