Package: ddisasm
Version: 1.5.3-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm/ddisasm_1.5.3-focal_amd64.deb
Size: 5108
SHA256: 862121b8db10e28e7559a1033f87847e2513a46ef7b30e6fa1b19da59eacbd2b
SHA1: 0851345b5a5b04f1062f3376cb358f0daf4b25a6
MD5sum: b8bc85f6670b4073151ded2a9ed98e2a
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
  Datalog Disassembly
  ===================
  .
  DDisasm is a *fast* disassembler which is *accurate* enough for the
  resulting assembly code to be reassembled.  DDisasm is implemented
  using the datalog ([souffle](https://github.com/souffle-lang/souffle))
  declarative logic programming language to compile disassembly rules
  and heuristics.  The disassembler first parses ELF file information
  and decodes a superset of possible instructions to create an initial
  set of datalog facts.  These facts are analyzed to identify *code
  location*, *symbolization*, and *function boundaries*.  The results of
  this analysis, a refined set of datalog facts, are then translated to
  the [GTIRB](https://github.com/grammatech/gtirb) intermediate
  representation for binary analysis and reverse engineering.  The
  [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
  may then be used to pretty print the GTIRB to reassemblable assembly
  code.
  .
  Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
  Docker image to try out `ddisasm` quickly.
  .
  ddisasm supports disassembling ELF and PE binary formats on x86_32, x86_64,
  ARM32, ARM64, and MIPS32 architectures.
  .
  ## Usage
  .
  ddisasm can be used to disassemble an ELF binary:
  .
  ```
  ddisasm examples/ex1/ex --asm ex.s
  ```
  .
  The generated assembly can then be rebuilt with gcc:
  .
  ```
  gcc ex.s -o ex_rewritten
  ```
  .
  ## Installing
  .
  Pre-built packages are available to install ddisasm on Windows or Ubuntu.
  .
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for details.
  .
  ## Dependencies
  .
  ddisasm uses C++17, and requires a compiler which supports
  that standard such as gcc 7, clang 6, or MSVC 2017.
  .
  To build ddisasm from source, the following requirements should be installed:
  .
  - [gtirb](https://github.com/grammatech/gtirb)
  - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
  - [Capstone](http://www.capstone-engine.org/), version 5.0.0 or later
    - 5.x is not yet released by the Capstone team.
    - GrammaTech builds and tests using the [GrammaTech/capstone](https://github.com/GrammaTech/capstone) fork.
  - [Souffle](https://souffle-lang.github.io), version 2.2
    - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
  - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
  - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
  .
  Note that these versions are newer than what your package manager may provide
  by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
  these dependencies from sources to avoid versioning problems. Alternatively,
  you can use the GrammaTech PPA to get the correct versions of the dependencies.
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for
  instructions on using the GrammaTech PPA.
  .
  ## Building ddisasm
  Use the following options to configure cmake:
  .
  - You can tell CMake which compiler to use with
    `-DCMAKE_CXX_COMPILER=<compiler>`.
  .
  - You can tell CMake about the paths to its dependencies as follows:
  .
   Option | Use
   ------ | -----
   `LIEF_ROOT` | Path to the LIEF installation dir
   `gtirb_DIR` | Path to the GTIRB installation dir
   `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
  .
  - ddisasm can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
  .
  Once the dependencies are installed, you can configure and build as
  follows:
  .
  ```
  $ cmake ./ -Bbuild
  $ cd build
  $ make
  ```
  .
  ### Debug build options
  .
  One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
  For example:
  ```
  $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
  ```
  will deactivate ARM_64 and X86_32 support.
  .
  ## Running the analysis
  .
  Once `ddisasm` is built, we can run complete analysis on a file by
  calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
  of the examples as follows:
  .
  ```
  cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
  ```
  .
  Ddisasm accepts the following parameters:
  .
  `--help`
  :   produce help message
  .
  `--ir arg`
  :   GTIRB output file
  .
  `--json arg`
  :   GTIRB json output file
  .
  `--asm arg`
  :   ASM output file
  .
  `--debug`
  :   if the assembly code is printed, it is printed with debugging information
  .
  `--debug-dir arg`
  :   location to write CSV files for debugging
  .
  `-K [ --keep-functions ] arg`
  :   Print the given functions even if they are skipped by default (e.g. _start)
  .
  `--self-diagnose`
  :   This option is useful for debugging. Use relocation information to emit a self diagnosis
      of the symbolization process. This option only works if the target
      binary contains complete relocation information. You can enable
      that in `ld` using the option `--emit-relocs`.
  .
  `-F [ --skip-function-analysis ]`
  :   Skip additional analyses to compute more precise function boundaries.
  .
  `-j [ --threads ]`
  :   Number of cores to use. It is set to the number of cores in the machine by default.
  .
  `-I [ --interpreter ] arg`
  :   Execute the Souffle interpreter with the specified source file.
  .
  `-L [ --library-dir ] arg`
  :   Specify the search directory for the Souffle interpreter to locate functor libraries.
  .
  `--profile arg`
  :   Execute the Souffle profiler to generate the specified profile log file.
  .
  ## Testing
  .
  To run the test suite, run:
  .
  ```
  cd build && PATH=$(pwd)/bin:$PATH ctest
  ```
  .
  ## Contributing
  .
  See [CONTRIBUTING.md](CONTRIBUTING.md)
  .
  ## External Contributors
  .
   * Programming Language Group, The University of Sydney: Initial support for ARM64.
  .
  .
  ## AuxData generated by ddisasm
  .
  ddisasm generates the following AuxData tables:
  .
  | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
  |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
  | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
  | ddisasmVersion          | `std::string`                                                                                      | The version of ddisasm used to produce the GTIRB. E.g. "1.5.3 (8533031c 2022-03-31) X64" represents version "1.5.3" compiled with commit "8533031c" with support for the "X64" ISA.                                    |
  | dynamicEntries          | `std::set<std::tuple<std::string, uint64_t>>`                                                      | Dynamic section entries: Name and  value.                                                                                                                                                                              |
  | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of each function.                                                                                                                                                            |
  | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
  | functionNames           | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | UUID of the symbol holding the string name of each function.                                                                                                                                                           |
  | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
  | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
  | sectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section type and flags.                                                                                                                                                     |
  | sectionIndex         | `std::map<uint64_t, gtirb::UUID>`                                                                  | Map from ELF section indices to section UUIDs.                                                                                                                                                                            |
  | elfSymbolInfo           | `std::map<gtirb::UUID, std::tuple<uint64_t, std::string, std::string, std::string, uint64_t>>`     | Map from symbol UUIDs to their ELF Symbol information containing the Size, Type, Binding, Visibility, and SectionIndex of the symbol.  Type can be "NOTYPE", "OBJECT", "FUNC", etc. Binding can be "LOCAL", "GLOBAL", or "WEAK". Visibility can be "DEFAULT", "HIDDEN", "PROTECTED", etc. For a complete list of possible values see e.g. https://refspecs.linuxbase.org/elf/gabi4+/ch4.symtab.html                                     |
  | elfSymbolTabIdxInfo     | `std::map<gtirb::UUID, std::vector<std::tuple<std::string, uint64_t>>>`                            | Map from symbol UUIDs to symbol section information including the names of the symbol tables where the symbol was declared (typically ".dynsym" or ".symtab") and the index within that table.                         |
  | elfSymbolVersions       | `std::map<gtirb::UUID, std::string>`                                                               | Map from symbol UUIDs to their ELF symbol version suffix if present. E.g. "@GLIBC_2.2.5".                                                                                                                              |
  | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
  | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
  | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
  | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
  | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
  | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
  | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
  | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
  | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
  | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
  | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
  | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
  | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
  .
  ## Some References
  .
  1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
  .
  2. [Souffle](https://github.com/souffle-lang/souffle)
  .
  3. [Capstone disassembler](http://www.capstone-engine.org/)
  .
  4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
  .
  5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
  .
  6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
  .
  7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
  .
  8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
  .
  9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
  .
Depends: ddisasm-1.5.3 (= 1.5.3-focal)

Package: ddisasm-1.4.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgomp1, libgtirb-1.10.3 (= 1.10.3-focal), libgtirb-pprinter-1.6.0 (= 1.6.0-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.1-gt3 (= 1:4.0.1-gt3)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-1.4.0/ddisasm-1.4.0_1.4.0-focal_amd64.deb
Size: 4173048
SHA256: becb3a1966e94aa0ed2a1f565a7729749de2495a305976ace7f9cfaf22098a0c
SHA1: ed55f33666a49d579353a99c34e568c2ab0a17ba
MD5sum: abb6f06c7a4d41ea6ca074a3d9aa2a49
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install ddisasm, the following requirements
 should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 4.0.1-focal or later
 - [Souffle](https://souffle-lang.github.io), version 2.0.2-focal
   - Must be configured with support for 64 bit numbers (via `--enable-64bit-domain` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0-focal or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.10.0-focal or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 .
 ### Ubuntu16
 ```sh
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb https://grammatech.github.io/gtirb/pkgs/xenial ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ### Ubuntu18
 ```sh
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ## Installing ddisasm on ubuntu16 and 18
 Packages for Ubuntu 16 and 18 are available in the GTIRB apt repository.
 Ddisasm has some dependencies which are not available in the official
 repositories, and so certain PPAs must be added to the system in order for
 Ddisasm to be installed.
 .
 Instructions for adding the appropriate PPAS are listed above, and can be used
 to install ddisasm as described below.
 .
 ### Ubuntu16
 ```sh
 sudo apt-get install --allow-unauthenticated ddisasm
 ```
 .
 ### Ubuntu18
 ```sh
 sudo apt-get install ddisasm
 ```
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 ## Rewriting a project
 .
 The directory tests/ contains the script `reassemble_and_test.sh` to
 rewrite and test a complete project. `reassemble_and_test.sh` rebuilds
 a project using the compiler and compiler flags specified in the
 enviroment variables CC and CFLAGS (`make -e`), rewrites the binary
 and run the project tests on the new binary.
 .
 We can rewrite ex1 as follows:
 .
 ```
 cd examples/ex1
 make
 ddisasm ex --asm ex.s
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Testing
 .
 The directory `tests/` also contains a script `test_small.sh` for
 rewriting the examples in `/examples` with different compilers and
 optimization flags.
 .
 .
 ## Contributing
 .
 Please read the [DDisasm Code of Conduct](CODE_OF_CONDUCT.md).
 .
 Please follow the Code Requirements in
 [gtirb/CONTRIBUTING](https://github.com/GrammaTech/gtirb/blob/master/CONTRIBUTING.md#code-requirements).
 .
 We ask that all contributors complete our Contributor License
 Agreement (CLA), which can be found at
 [GrammaTech-CLA-ddisasm.pdfGTIRB.pdf](./GrammaTech-CLA-ddisasm.pdfGTIRB.pdf),
 and email the completed form to `CLA@GrammaTech.com`.  Under this
 agreement contributors retain the copyright to their work but grants
 GrammaTech unlimited license to the work.
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of functions.                                                                                                                                                                |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | elfSectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section types and flags.                                                                                                                                                 |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.4.0-focal
Installed-Size: 33938

Package: ddisasm-1.5.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgomp1, libgtirb-1.10.4 (=1.10.4-focal), libgtirb-pprinter-1.7.0 (=1.7.0-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-1.5.0/ddisasm-1.5.0_1.5.0-focal_amd64.deb
Size: 8614610
SHA256: b831db16305830a87a6a4d2c7968c55e7cc46c4ab27788efa98f7291d313b6fa
SHA1: 4b1a87f33648c7b2979c8b67e674ed5b3442a017
MD5sum: c44011aac5932bf865af6d43cb917cca
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install ddisasm, the following requirements
 should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 4.0.1 or later
 - [Souffle](https://souffle-lang.github.io), version 2.0.2
   - Must be configured with support for 64 bit numbers (via `--enable-64bit-domain` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.10.0 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 .
 ### Ubuntu16
 ```sh
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb https://grammatech.github.io/gtirb/pkgs/xenial ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ### Ubuntu18
 ```sh
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ### Souffle interpreter
 .
 For accelerated development of datalog logic, ddisasm can also execute the
 souffle interpreter. To invoke the interpreter, specify a `--debug-dir`
 directory path and the `--intepreter` parameter with the path of ddisasm's
 datalog entry.
 .
 For example:
 ```
 $ cd ddisasm/examples/ex1
 $ make
 $ mkdir dbg
 $ ddisasm --debug-dir dbg --interpreter ../../src/datalog/main.dl --asm ex.s ex
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the souffle interpreter with the specified source file.
 .
 ## Rewriting a project
 .
 The directory tests/ contains the script `reassemble_and_test.sh` to
 rewrite and test a complete project. `reassemble_and_test.sh` rebuilds
 a project using the compiler and compiler flags specified in the
 enviroment variables CC and CFLAGS (`make -e`), rewrites the binary
 and run the project tests on the new binary.
 .
 We can rewrite ex1 as follows:
 .
 ```
 cd examples/ex1
 make
 ddisasm ex --asm ex.s
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Testing
 .
 The directory `tests/` also contains a script `test_small.sh` for
 rewriting the examples in `/examples` with different compilers and
 optimization flags.
 .
 .
 ## Contributing
 .
 Please read the [DDisasm Code of Conduct](CODE_OF_CONDUCT.md).
 .
 Please follow the Code Requirements in
 [gtirb/CONTRIBUTING](https://github.com/GrammaTech/gtirb/blob/master/CONTRIBUTING.md#code-requirements).
 .
 We ask that all contributors complete our Contributor License
 Agreement (CLA), which can be found at
 [GrammaTech-CLA-ddisasm.pdfGTIRB.pdf](./GrammaTech-CLA-ddisasm.pdfGTIRB.pdf),
 and email the completed form to `CLA@GrammaTech.com`.  Under this
 agreement contributors retain the copyright to their work but grants
 GrammaTech unlimited license to the work.
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of functions.                                                                                                                                                                |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | elfSectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section types and flags.                                                                                                                                                 |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.0-focal
Installed-Size: 32032

Package: ddisasm-1.5.1
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgomp1, libgtirb-1.10.5 (=1.10.5-focal), libgtirb-pprinter-1.8.0 (=1.8.0-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-1.5.1/ddisasm-1.5.1_1.5.1-focal_amd64.deb
Size: 8183530
SHA256: 01aca9287a7f47e01ef9c4a8ad93d146d2317c4d655ffd8a49420bdbdbd89eae
SHA1: c17279453a8a25d9a01d0fd1321709a23d1eb3b9
MD5sum: eade35754705e2ec029890c4a98bb97a
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install ddisasm, the following requirements
 should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 4.0.1 or later
 - [Souffle](https://souffle-lang.github.io), version 2.1
   - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 .
 ### Ubuntu16
 ```sh
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb https://grammatech.github.io/gtirb/pkgs/xenial ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ### Ubuntu18
 ```sh
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ### Souffle interpreter
 .
 For accelerated development of datalog logic, ddisasm can also execute the
 souffle interpreter. To invoke the interpreter, specify a `--debug-dir`
 directory path and the `--intepreter` parameter with the path of ddisasm's
 datalog entry.
 .
 For example:
 ```
 $ cd ddisasm/examples/ex1
 $ make
 $ mkdir dbg
 $ ddisasm --debug-dir dbg --interpreter ../../src/datalog/main.dl --asm ex.s ex
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the souffle interpreter with the specified source file.
 .
 ## Rewriting a project
 .
 The directory tests/ contains the script `reassemble_and_test.sh` to
 rewrite and test a complete project. `reassemble_and_test.sh` rebuilds
 a project using the compiler and compiler flags specified in the
 enviroment variables CC and CFLAGS (`make -e`), rewrites the binary
 and run the project tests on the new binary.
 .
 We can rewrite ex1 as follows:
 .
 ```
 cd examples/ex1
 make
 ddisasm ex --asm ex.s
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Testing
 .
 The directory `tests/` also contains a script `test_small.sh` for
 rewriting the examples in `/examples` with different compilers and
 optimization flags.
 .
 .
 ## Contributing
 .
 Please read the [DDisasm Code of Conduct](CODE_OF_CONDUCT.md).
 .
 Please follow the Code Requirements in
 [gtirb/CONTRIBUTING](https://github.com/GrammaTech/gtirb/blob/master/CONTRIBUTING.md#code-requirements).
 .
 We ask that all contributors complete our Contributor License
 Agreement (CLA), which can be found at
 [GrammaTech-CLA-ddisasm.pdfGTIRB.pdf](./GrammaTech-CLA-ddisasm.pdfGTIRB.pdf),
 and email the completed form to `CLA@GrammaTech.com`.  Under this
 agreement contributors retain the copyright to their work but grants
 GrammaTech unlimited license to the work.
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of functions.                                                                                                                                                                |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | elfSectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section types and flags.                                                                                                                                                 |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.1-focal
Installed-Size: 28169

Package: ddisasm-1.5.2
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgomp1, libgtirb-1.10.6 (=1.10.6-focal), libgtirb-pprinter-1.8.2 (=1.8.2-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.2-gt1 (=1:4.0.2-gt1)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-1.5.2/ddisasm-1.5.2_1.5.2-focal_amd64.deb
Size: 8472680
SHA256: 49cc40a9deab8de85d0a9eaf7dccfd1c38c5424a00c16da89312fabcb364a3fc
SHA1: 0116d485b3a850d27193ddf6359e5ac747f0143e
MD5sum: 4c123f3285917f5191a38ddbd4e99447
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install ddisasm, the following requirements
 should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 4.0.1 or later
 - [Souffle](https://souffle-lang.github.io), version 2.1
   - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for
 instructions on using the GrammaTech PPA.
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ### Souffle interpreter
 .
 For accelerated development of datalog logic, ddisasm can also execute the
 souffle interpreter. To invoke the interpreter, specify a `--debug-dir`
 directory path and the `--intepreter` parameter with the path of ddisasm's
 datalog entry.
 .
 For example:
 ```
 $ cd ddisasm/examples/ex1
 $ make
 $ mkdir dbg
 $ ddisasm --debug-dir dbg --interpreter ../../src/datalog/main.dl --asm ex.s ex
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the souffle interpreter with the specified source file.
 .
 ## Rewriting a project
 .
 The directory tests/ contains the script `reassemble_and_test.sh` to
 rewrite and test a complete project. `reassemble_and_test.sh` rebuilds
 a project using the compiler and compiler flags specified in the
 enviroment variables CC and CFLAGS (`make -e`), rewrites the binary
 and run the project tests on the new binary.
 .
 We can rewrite ex1 as follows:
 .
 ```
 cd examples/ex1
 make
 ddisasm ex --asm ex.s
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Testing
 .
 The directory `tests/` also contains a script `test_small.sh` for
 rewriting the examples in `/examples` with different compilers and
 optimization flags.
 .
 .
 ## Contributing
 .
 Please read the [DDisasm Code of Conduct](CODE_OF_CONDUCT.md).
 .
 Please follow the Code Requirements in
 [gtirb/CONTRIBUTING](https://github.com/GrammaTech/gtirb/blob/master/CONTRIBUTING.md#code-requirements).
 .
 We ask that all contributors complete our Contributor License
 Agreement (CLA), which can be found at
 [GrammaTech-CLA-ddisasm.pdfGTIRB.pdf](./GrammaTech-CLA-ddisasm.pdfGTIRB.pdf),
 and email the completed form to `CLA@GrammaTech.com`.  Under this
 agreement contributors retain the copyright to their work but grants
 GrammaTech unlimited license to the work.
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of each function.                                                                                                                                                            |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | functionNames           | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | UUID of the symbol holding the string name of each function.                                                                                                                                                           |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | elfSectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section type and flags.                                                                                                                                                  |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.2-focal
Installed-Size: 27899

Package: ddisasm-1.5.3
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgomp1, libgtirb-1.10.7 (=1.10.7-focal), libgtirb-pprinter-1.8.3 (=1.8.3-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-5.0.0-gt2 (=1:5.0.0-gt2)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-1.5.3/ddisasm-1.5.3_1.5.3-focal_amd64.deb
Size: 12356936
SHA256: 33b1c4630061b0744dff031c1fc0dd335e32c39305afdc10d700eba1b677f9e2
SHA1: cd7f2cd739389515003ca235b98975a5516e388c
MD5sum: d9e2426f6cae189fea9469bc1ade8011
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ddisasm supports disassembling ELF and PE binary formats on x86_32, x86_64,
 ARM32, ARM64, and MIPS32 architectures.
 .
 ## Usage
 .
 ddisasm can be used to disassemble an ELF binary:
 .
 ```
 ddisasm examples/ex1/ex --asm ex.s
 ```
 .
 The generated assembly can then be rebuilt with gcc:
 .
 ```
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Installing
 .
 Pre-built packages are available to install ddisasm on Windows or Ubuntu.
 .
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for details.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build ddisasm from source, the following requirements should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 5.0.0 or later
   - 5.x is not yet released by the Capstone team.
   - GrammaTech builds and tests using the [GrammaTech/capstone](https://github.com/GrammaTech/capstone) fork.
 - [Souffle](https://souffle-lang.github.io), version 2.2
   - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for
 instructions on using the GrammaTech PPA.
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the Souffle interpreter with the specified source file.
 .
 `-L [ --library-dir ] arg`
 :   Specify the search directory for the Souffle interpreter to locate functor libraries.
 .
 `--profile arg`
 :   Execute the Souffle profiler to generate the specified profile log file.
 .
 ## Testing
 .
 To run the test suite, run:
 .
 ```
 cd build && PATH=$(pwd)/bin:$PATH ctest
 ```
 .
 ## Contributing
 .
 See [CONTRIBUTING.md](CONTRIBUTING.md)
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | ddisasmVersion          | `std::string`                                                                                      | The version of ddisasm used to produce the GTIRB. E.g. "1.5.3 (8533031c 2022-03-31) X64" represents version "1.5.3" compiled with commit "8533031c" with support for the "X64" ISA.                                    |
 | dynamicEntries          | `std::set<std::tuple<std::string, uint64_t>>`                                                      | Dynamic section entries: Name and  value.                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of each function.                                                                                                                                                            |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | functionNames           | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | UUID of the symbol holding the string name of each function.                                                                                                                                                           |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | sectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section type and flags.                                                                                                                                                     |
 | sectionIndex         | `std::map<uint64_t, gtirb::UUID>`                                                                  | Map from ELF section indices to section UUIDs.                                                                                                                                                                            |
 | elfSymbolInfo           | `std::map<gtirb::UUID, std::tuple<uint64_t, std::string, std::string, std::string, uint64_t>>`     | Map from symbol UUIDs to their ELF Symbol information containing the Size, Type, Binding, Visibility, and SectionIndex of the symbol.  Type can be "NOTYPE", "OBJECT", "FUNC", etc. Binding can be "LOCAL", "GLOBAL", or "WEAK". Visibility can be "DEFAULT", "HIDDEN", "PROTECTED", etc. For a complete list of possible values see e.g. https://refspecs.linuxbase.org/elf/gabi4+/ch4.symtab.html                                     |
 | elfSymbolTabIdxInfo     | `std::map<gtirb::UUID, std::vector<std::tuple<std::string, uint64_t>>>`                            | Map from symbol UUIDs to symbol section information including the names of the symbol tables where the symbol was declared (typically ".dynsym" or ".symtab") and the index within that table.                         |
 | elfSymbolVersions       | `std::map<gtirb::UUID, std::string>`                                                               | Map from symbol UUIDs to their ELF symbol version suffix if present. E.g. "@GLIBC_2.2.5".                                                                                                                              |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.3-focal
Installed-Size: 42583

Package: ddisasm-dbg
Version: 1.5.3-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-dbg/ddisasm-dbg_1.5.3-focal_amd64.deb
Size: 5112
SHA256: 080241ce47216c79b9ff5d9fae94e4a4879a465cd2104c3ebb602aa379b3ba8a
SHA1: 01d208ab44cb04691960f0fbeee73dcc19ff13e3
MD5sum: d1921579d5ca7ff340e2e8d605f874cf
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
  Datalog Disassembly
  ===================
  .
  DDisasm is a *fast* disassembler which is *accurate* enough for the
  resulting assembly code to be reassembled.  DDisasm is implemented
  using the datalog ([souffle](https://github.com/souffle-lang/souffle))
  declarative logic programming language to compile disassembly rules
  and heuristics.  The disassembler first parses ELF file information
  and decodes a superset of possible instructions to create an initial
  set of datalog facts.  These facts are analyzed to identify *code
  location*, *symbolization*, and *function boundaries*.  The results of
  this analysis, a refined set of datalog facts, are then translated to
  the [GTIRB](https://github.com/grammatech/gtirb) intermediate
  representation for binary analysis and reverse engineering.  The
  [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
  may then be used to pretty print the GTIRB to reassemblable assembly
  code.
  .
  Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
  Docker image to try out `ddisasm` quickly.
  .
  ddisasm supports disassembling ELF and PE binary formats on x86_32, x86_64,
  ARM32, ARM64, and MIPS32 architectures.
  .
  ## Usage
  .
  ddisasm can be used to disassemble an ELF binary:
  .
  ```
  ddisasm examples/ex1/ex --asm ex.s
  ```
  .
  The generated assembly can then be rebuilt with gcc:
  .
  ```
  gcc ex.s -o ex_rewritten
  ```
  .
  ## Installing
  .
  Pre-built packages are available to install ddisasm on Windows or Ubuntu.
  .
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for details.
  .
  ## Dependencies
  .
  ddisasm uses C++17, and requires a compiler which supports
  that standard such as gcc 7, clang 6, or MSVC 2017.
  .
  To build ddisasm from source, the following requirements should be installed:
  .
  - [gtirb](https://github.com/grammatech/gtirb)
  - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
  - [Capstone](http://www.capstone-engine.org/), version 5.0.0 or later
    - 5.x is not yet released by the Capstone team.
    - GrammaTech builds and tests using the [GrammaTech/capstone](https://github.com/GrammaTech/capstone) fork.
  - [Souffle](https://souffle-lang.github.io), version 2.2
    - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
  - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
  - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
  .
  Note that these versions are newer than what your package manager may provide
  by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
  these dependencies from sources to avoid versioning problems. Alternatively,
  you can use the GrammaTech PPA to get the correct versions of the dependencies.
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for
  instructions on using the GrammaTech PPA.
  .
  ## Building ddisasm
  Use the following options to configure cmake:
  .
  - You can tell CMake which compiler to use with
    `-DCMAKE_CXX_COMPILER=<compiler>`.
  .
  - You can tell CMake about the paths to its dependencies as follows:
  .
   Option | Use
   ------ | -----
   `LIEF_ROOT` | Path to the LIEF installation dir
   `gtirb_DIR` | Path to the GTIRB installation dir
   `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
  .
  - ddisasm can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
  .
  Once the dependencies are installed, you can configure and build as
  follows:
  .
  ```
  $ cmake ./ -Bbuild
  $ cd build
  $ make
  ```
  .
  ### Debug build options
  .
  One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
  For example:
  ```
  $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
  ```
  will deactivate ARM_64 and X86_32 support.
  .
  ## Running the analysis
  .
  Once `ddisasm` is built, we can run complete analysis on a file by
  calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
  of the examples as follows:
  .
  ```
  cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
  ```
  .
  Ddisasm accepts the following parameters:
  .
  `--help`
  :   produce help message
  .
  `--ir arg`
  :   GTIRB output file
  .
  `--json arg`
  :   GTIRB json output file
  .
  `--asm arg`
  :   ASM output file
  .
  `--debug`
  :   if the assembly code is printed, it is printed with debugging information
  .
  `--debug-dir arg`
  :   location to write CSV files for debugging
  .
  `-K [ --keep-functions ] arg`
  :   Print the given functions even if they are skipped by default (e.g. _start)
  .
  `--self-diagnose`
  :   This option is useful for debugging. Use relocation information to emit a self diagnosis
      of the symbolization process. This option only works if the target
      binary contains complete relocation information. You can enable
      that in `ld` using the option `--emit-relocs`.
  .
  `-F [ --skip-function-analysis ]`
  :   Skip additional analyses to compute more precise function boundaries.
  .
  `-j [ --threads ]`
  :   Number of cores to use. It is set to the number of cores in the machine by default.
  .
  `-I [ --interpreter ] arg`
  :   Execute the Souffle interpreter with the specified source file.
  .
  `-L [ --library-dir ] arg`
  :   Specify the search directory for the Souffle interpreter to locate functor libraries.
  .
  `--profile arg`
  :   Execute the Souffle profiler to generate the specified profile log file.
  .
  ## Testing
  .
  To run the test suite, run:
  .
  ```
  cd build && PATH=$(pwd)/bin:$PATH ctest
  ```
  .
  ## Contributing
  .
  See [CONTRIBUTING.md](CONTRIBUTING.md)
  .
  ## External Contributors
  .
   * Programming Language Group, The University of Sydney: Initial support for ARM64.
  .
  .
  ## AuxData generated by ddisasm
  .
  ddisasm generates the following AuxData tables:
  .
  | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
  |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
  | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
  | ddisasmVersion          | `std::string`                                                                                      | The version of ddisasm used to produce the GTIRB. E.g. "1.5.3 (8533031c 2022-03-31) X64" represents version "1.5.3" compiled with commit "8533031c" with support for the "X64" ISA.                                    |
  | dynamicEntries          | `std::set<std::tuple<std::string, uint64_t>>`                                                      | Dynamic section entries: Name and  value.                                                                                                                                                                              |
  | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of each function.                                                                                                                                                            |
  | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
  | functionNames           | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | UUID of the symbol holding the string name of each function.                                                                                                                                                           |
  | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
  | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
  | sectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section type and flags.                                                                                                                                                     |
  | sectionIndex         | `std::map<uint64_t, gtirb::UUID>`                                                                  | Map from ELF section indices to section UUIDs.                                                                                                                                                                            |
  | elfSymbolInfo           | `std::map<gtirb::UUID, std::tuple<uint64_t, std::string, std::string, std::string, uint64_t>>`     | Map from symbol UUIDs to their ELF Symbol information containing the Size, Type, Binding, Visibility, and SectionIndex of the symbol.  Type can be "NOTYPE", "OBJECT", "FUNC", etc. Binding can be "LOCAL", "GLOBAL", or "WEAK". Visibility can be "DEFAULT", "HIDDEN", "PROTECTED", etc. For a complete list of possible values see e.g. https://refspecs.linuxbase.org/elf/gabi4+/ch4.symtab.html                                     |
  | elfSymbolTabIdxInfo     | `std::map<gtirb::UUID, std::vector<std::tuple<std::string, uint64_t>>>`                            | Map from symbol UUIDs to symbol section information including the names of the symbol tables where the symbol was declared (typically ".dynsym" or ".symtab") and the index within that table.                         |
  | elfSymbolVersions       | `std::map<gtirb::UUID, std::string>`                                                               | Map from symbol UUIDs to their ELF symbol version suffix if present. E.g. "@GLIBC_2.2.5".                                                                                                                              |
  | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
  | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
  | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
  | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
  | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
  | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
  | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
  | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
  | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
  | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
  | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
  | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
  | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
  .
  ## Some References
  .
  1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
  .
  2. [Souffle](https://github.com/souffle-lang/souffle)
  .
  3. [Capstone disassembler](http://www.capstone-engine.org/)
  .
  4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
  .
  5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
  .
  6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
  .
  7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
  .
  8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
  .
  9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
  .
Depends: ddisasm-dbg-1.5.3 (= 1.5.3-focal)

Package: ddisasm-dbg-1.5.0
Architecture: amd64
Depends: ddisasm-1.5.0 (=1.5.0-focal)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-dbg-1.5.0/ddisasm-dbg-1.5.0_1.5.0-focal_amd64.deb
Size: 141744956
SHA256: 1acf467c3eeade77f7c9f77dd37b78f54e6e952d4ade9291f5b60882241f1603
SHA1: 65bb8d1972ca93ba27d9e7696cc531dafd328223
MD5sum: 1a56241db3b173bb6ccd2538d9a5c625
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install ddisasm, the following requirements
 should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 4.0.1 or later
 - [Souffle](https://souffle-lang.github.io), version 2.0.2
   - Must be configured with support for 64 bit numbers (via `--enable-64bit-domain` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.10.0 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 .
 ### Ubuntu16
 ```sh
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb https://grammatech.github.io/gtirb/pkgs/xenial ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ### Ubuntu18
 ```sh
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ### Souffle interpreter
 .
 For accelerated development of datalog logic, ddisasm can also execute the
 souffle interpreter. To invoke the interpreter, specify a `--debug-dir`
 directory path and the `--intepreter` parameter with the path of ddisasm's
 datalog entry.
 .
 For example:
 ```
 $ cd ddisasm/examples/ex1
 $ make
 $ mkdir dbg
 $ ddisasm --debug-dir dbg --interpreter ../../src/datalog/main.dl --asm ex.s ex
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the souffle interpreter with the specified source file.
 .
 ## Rewriting a project
 .
 The directory tests/ contains the script `reassemble_and_test.sh` to
 rewrite and test a complete project. `reassemble_and_test.sh` rebuilds
 a project using the compiler and compiler flags specified in the
 enviroment variables CC and CFLAGS (`make -e`), rewrites the binary
 and run the project tests on the new binary.
 .
 We can rewrite ex1 as follows:
 .
 ```
 cd examples/ex1
 make
 ddisasm ex --asm ex.s
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Testing
 .
 The directory `tests/` also contains a script `test_small.sh` for
 rewriting the examples in `/examples` with different compilers and
 optimization flags.
 .
 .
 ## Contributing
 .
 Please read the [DDisasm Code of Conduct](CODE_OF_CONDUCT.md).
 .
 Please follow the Code Requirements in
 [gtirb/CONTRIBUTING](https://github.com/GrammaTech/gtirb/blob/master/CONTRIBUTING.md#code-requirements).
 .
 We ask that all contributors complete our Contributor License
 Agreement (CLA), which can be found at
 [GrammaTech-CLA-ddisasm.pdfGTIRB.pdf](./GrammaTech-CLA-ddisasm.pdfGTIRB.pdf),
 and email the completed form to `CLA@GrammaTech.com`.  Under this
 agreement contributors retain the copyright to their work but grants
 GrammaTech unlimited license to the work.
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of functions.                                                                                                                                                                |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | elfSectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section types and flags.                                                                                                                                                 |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.0-focal
Installed-Size: 665378

Package: ddisasm-dbg-1.5.1
Architecture: amd64
Depends: ddisasm-1.5.1 (=1.5.1-focal)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-dbg-1.5.1/ddisasm-dbg-1.5.1_1.5.1-focal_amd64.deb
Size: 143704850
SHA256: 802fb298f71a77aafb002c1f9182451075a605b46c53690112e56ae6ba6335cb
SHA1: 3a8354d05305db5be98fd1c1b96d4ebfc779c1c6
MD5sum: 63be9939d39eac614c75bc04d14805c9
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install ddisasm, the following requirements
 should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 4.0.1 or later
 - [Souffle](https://souffle-lang.github.io), version 2.1
   - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 .
 ### Ubuntu16
 ```sh
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb https://grammatech.github.io/gtirb/pkgs/xenial ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ### Ubuntu18
 ```sh
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo "deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./" | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 ```
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ### Souffle interpreter
 .
 For accelerated development of datalog logic, ddisasm can also execute the
 souffle interpreter. To invoke the interpreter, specify a `--debug-dir`
 directory path and the `--intepreter` parameter with the path of ddisasm's
 datalog entry.
 .
 For example:
 ```
 $ cd ddisasm/examples/ex1
 $ make
 $ mkdir dbg
 $ ddisasm --debug-dir dbg --interpreter ../../src/datalog/main.dl --asm ex.s ex
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the souffle interpreter with the specified source file.
 .
 ## Rewriting a project
 .
 The directory tests/ contains the script `reassemble_and_test.sh` to
 rewrite and test a complete project. `reassemble_and_test.sh` rebuilds
 a project using the compiler and compiler flags specified in the
 enviroment variables CC and CFLAGS (`make -e`), rewrites the binary
 and run the project tests on the new binary.
 .
 We can rewrite ex1 as follows:
 .
 ```
 cd examples/ex1
 make
 ddisasm ex --asm ex.s
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Testing
 .
 The directory `tests/` also contains a script `test_small.sh` for
 rewriting the examples in `/examples` with different compilers and
 optimization flags.
 .
 .
 ## Contributing
 .
 Please read the [DDisasm Code of Conduct](CODE_OF_CONDUCT.md).
 .
 Please follow the Code Requirements in
 [gtirb/CONTRIBUTING](https://github.com/GrammaTech/gtirb/blob/master/CONTRIBUTING.md#code-requirements).
 .
 We ask that all contributors complete our Contributor License
 Agreement (CLA), which can be found at
 [GrammaTech-CLA-ddisasm.pdfGTIRB.pdf](./GrammaTech-CLA-ddisasm.pdfGTIRB.pdf),
 and email the completed form to `CLA@GrammaTech.com`.  Under this
 agreement contributors retain the copyright to their work but grants
 GrammaTech unlimited license to the work.
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of functions.                                                                                                                                                                |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | elfSectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section types and flags.                                                                                                                                                 |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.1-focal
Installed-Size: 673379

Package: ddisasm-dbg-1.5.2
Architecture: amd64
Depends: ddisasm-1.5.2 (=1.5.2-focal)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-dbg-1.5.2/ddisasm-dbg-1.5.2_1.5.2-focal_amd64.deb
Size: 148943998
SHA256: ea8c3bb7bdc9c1ff7e812858409af8f39aad69cf4ee9cb5a7960b1365a75f7c5
SHA1: c8c322f565fa69c68792b8272629847851c40964
MD5sum: 4c899320429835f4af339b9c5391d99b
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install ddisasm, the following requirements
 should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 4.0.1 or later
 - [Souffle](https://souffle-lang.github.io), version 2.1
   - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for
 instructions on using the GrammaTech PPA.
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ### Souffle interpreter
 .
 For accelerated development of datalog logic, ddisasm can also execute the
 souffle interpreter. To invoke the interpreter, specify a `--debug-dir`
 directory path and the `--intepreter` parameter with the path of ddisasm's
 datalog entry.
 .
 For example:
 ```
 $ cd ddisasm/examples/ex1
 $ make
 $ mkdir dbg
 $ ddisasm --debug-dir dbg --interpreter ../../src/datalog/main.dl --asm ex.s ex
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the souffle interpreter with the specified source file.
 .
 ## Rewriting a project
 .
 The directory tests/ contains the script `reassemble_and_test.sh` to
 rewrite and test a complete project. `reassemble_and_test.sh` rebuilds
 a project using the compiler and compiler flags specified in the
 enviroment variables CC and CFLAGS (`make -e`), rewrites the binary
 and run the project tests on the new binary.
 .
 We can rewrite ex1 as follows:
 .
 ```
 cd examples/ex1
 make
 ddisasm ex --asm ex.s
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Testing
 .
 The directory `tests/` also contains a script `test_small.sh` for
 rewriting the examples in `/examples` with different compilers and
 optimization flags.
 .
 .
 ## Contributing
 .
 Please read the [DDisasm Code of Conduct](CODE_OF_CONDUCT.md).
 .
 Please follow the Code Requirements in
 [gtirb/CONTRIBUTING](https://github.com/GrammaTech/gtirb/blob/master/CONTRIBUTING.md#code-requirements).
 .
 We ask that all contributors complete our Contributor License
 Agreement (CLA), which can be found at
 [GrammaTech-CLA-ddisasm.pdfGTIRB.pdf](./GrammaTech-CLA-ddisasm.pdfGTIRB.pdf),
 and email the completed form to `CLA@GrammaTech.com`.  Under this
 agreement contributors retain the copyright to their work but grants
 GrammaTech unlimited license to the work.
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of each function.                                                                                                                                                            |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | functionNames           | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | UUID of the symbol holding the string name of each function.                                                                                                                                                           |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | elfSectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section type and flags.                                                                                                                                                  |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.2-focal
Installed-Size: 692203

Package: ddisasm-dbg-1.5.3
Architecture: amd64
Depends: ddisasm-1.5.3 (=1.5.3-focal)
Priority: optional
Section: devel
Filename: pool/stable/d/ddisasm-dbg-1.5.3/ddisasm-dbg-1.5.3_1.5.3-focal_amd64.deb
Size: 256669920
SHA256: 2909dbeaa2efbf07001da931610b473765b9f960614e31d14e9264d8571fd342
SHA1: ce57da083de3209ffcc7fd24c5be6a4fd307d0e3
MD5sum: 56a2c278fc06b38692103c88d909a88d
Description: A fast disassembler which is accurate enough for the resulting assembly code to be reassembled. The disassembler implemented using the datalog (souffle) declarative logic programming language to compile disassembly rules and heuristics.
 Datalog Disassembly
 ===================
 .
 DDisasm is a *fast* disassembler which is *accurate* enough for the
 resulting assembly code to be reassembled.  DDisasm is implemented
 using the datalog ([souffle](https://github.com/souffle-lang/souffle))
 declarative logic programming language to compile disassembly rules
 and heuristics.  The disassembler first parses ELF file information
 and decodes a superset of possible instructions to create an initial
 set of datalog facts.  These facts are analyzed to identify *code
 location*, *symbolization*, and *function boundaries*.  The results of
 this analysis, a refined set of datalog facts, are then translated to
 the [GTIRB](https://github.com/grammatech/gtirb) intermediate
 representation for binary analysis and reverse engineering.  The
 [GTIRB pretty printer](https://github.com/grammatech/gtirb-pprinter)
 may then be used to pretty print the GTIRB to reassemblable assembly
 code.
 .
 Use the [grammatech/ddisasm](https://hub.docker.com/r/grammatech/ddisasm)
 Docker image to try out `ddisasm` quickly.
 .
 ddisasm supports disassembling ELF and PE binary formats on x86_32, x86_64,
 ARM32, ARM64, and MIPS32 architectures.
 .
 ## Usage
 .
 ddisasm can be used to disassemble an ELF binary:
 .
 ```
 ddisasm examples/ex1/ex --asm ex.s
 ```
 .
 The generated assembly can then be rebuilt with gcc:
 .
 ```
 gcc ex.s -o ex_rewritten
 ```
 .
 ## Installing
 .
 Pre-built packages are available to install ddisasm on Windows or Ubuntu.
 .
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for details.
 .
 ## Dependencies
 .
 ddisasm uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build ddisasm from source, the following requirements should be installed:
 .
 - [gtirb](https://github.com/grammatech/gtirb)
 - [gtirb-pprinter](https://github.com/grammatech/gtirb-pprinter)
 - [Capstone](http://www.capstone-engine.org/), version 5.0.0 or later
   - 5.x is not yet released by the Capstone team.
   - GrammaTech builds and tests using the [GrammaTech/capstone](https://github.com/GrammaTech/capstone) fork.
 - [Souffle](https://souffle-lang.github.io), version 2.2
   - Must be configured with support for 64 bit numbers (via `-DSOUFFLE_DOMAIN_64BIT=1` during configuration)
 - [libehp](https://git.zephyr-software.com/opensrc/libehp), version 1.0.0 or higher
 - [LIEF](https://lief.quarkslab.com/), version 0.11.5 or higher
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems. Alternatively,
 you can use the GrammaTech PPA to get the correct versions of the dependencies.
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing) for
 instructions on using the GrammaTech PPA.
 .
 ## Building ddisasm
 Use the following options to configure cmake:
 .
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=<compiler>`.
 .
 - You can tell CMake about the paths to its dependencies as follows:
 .
  Option | Use
  ------ | -----
  `LIEF_ROOT` | Path to the LIEF installation dir
  `gtirb_DIR` | Path to the GTIRB installation dir
  `gtirb_pprinter_DIR` | Path to the gtirb-pprinter build dir
 .
 - ddisasm can make use of GTIRB in static library form (instead of
  shared library form, the default) if you use the flag
  `-DDDISASM_BUILD_SHARED_LIBS=OFF`.
 .
 Once the dependencies are installed, you can configure and build as
 follows:
 .
 ```
 $ cmake ./ -Bbuild
 $ cd build
 $ make
 ```
 .
 ### Debug build options
 .
 One can selectively turn off ddisasm's various architecture support modules to speed up compilation time during development.
 For example:
 ```
 $ cmake ./ -Bbuild -DDDISASM_ARM_64=OFF -DDDISASM_X86_32=OFF
 ```
 will deactivate ARM_64 and X86_32 support.
 .
 ## Running the analysis
 .
 Once `ddisasm` is built, we can run complete analysis on a file by
 calling `build/bin/ddisasm'`.  For example, we can run the analysis on one
 of the examples as follows:
 .
 ```
 cd build/bin && ./ddisasm ../../examples/ex1/ex --asm ex.s
 ```
 .
 Ddisasm accepts the following parameters:
 .
 `--help`
 :   produce help message
 .
 `--ir arg`
 :   GTIRB output file
 .
 `--json arg`
 :   GTIRB json output file
 .
 `--asm arg`
 :   ASM output file
 .
 `--debug`
 :   if the assembly code is printed, it is printed with debugging information
 .
 `--debug-dir arg`
 :   location to write CSV files for debugging
 .
 `-K [ --keep-functions ] arg`
 :   Print the given functions even if they are skipped by default (e.g. _start)
 .
 `--self-diagnose`
 :   This option is useful for debugging. Use relocation information to emit a self diagnosis
     of the symbolization process. This option only works if the target
     binary contains complete relocation information. You can enable
     that in `ld` using the option `--emit-relocs`.
 .
 `-F [ --skip-function-analysis ]`
 :   Skip additional analyses to compute more precise function boundaries.
 .
 `-j [ --threads ]`
 :   Number of cores to use. It is set to the number of cores in the machine by default.
 .
 `-I [ --interpreter ] arg`
 :   Execute the Souffle interpreter with the specified source file.
 .
 `-L [ --library-dir ] arg`
 :   Specify the search directory for the Souffle interpreter to locate functor libraries.
 .
 `--profile arg`
 :   Execute the Souffle profiler to generate the specified profile log file.
 .
 ## Testing
 .
 To run the test suite, run:
 .
 ```
 cd build && PATH=$(pwd)/bin:$PATH ctest
 ```
 .
 ## Contributing
 .
 See [CONTRIBUTING.md](CONTRIBUTING.md)
 .
 ## External Contributors
 .
  * Programming Language Group, The University of Sydney: Initial support for ARM64.
 .
 .
 ## AuxData generated by ddisasm
 .
 ddisasm generates the following AuxData tables:
 .
 | Key                     | Type                                                                                               | Purpose                                                                                                                                                                                                                |
 |-------------------------|----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | binaryType              | `std::vector<std::string>`                                                                         | A set of binary type descriptors e.g. for ELF whether the binary is PIE "DYN" or not, "EXEC". PE binaries have additional descriptors, "DLL" or "EXE, and subsystem descriptor, e.g. WINDOWS_GUI or WINDOWS_CUI.       |
 | comments                | `std::map<gtirb::Offset, std::string>`                                                             | Per-instruction comments.                                                                                                                                                                                              |
 | ddisasmVersion          | `std::string`                                                                                      | The version of ddisasm used to produce the GTIRB. E.g. "1.5.3 (8533031c 2022-03-31) X64" represents version "1.5.3" compiled with commit "8533031c" with support for the "X64" ISA.                                    |
 | dynamicEntries          | `std::set<std::tuple<std::string, uint64_t>>`                                                      | Dynamic section entries: Name and  value.                                                                                                                                                                              |
 | functionEntries         | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that are entry points of each function.                                                                                                                                                            |
 | functionBlocks          | `std::map<gtirb::UUID, std::set<gtirb::UUID>>`                                                     | UUIDs of the blocks that belong to each function.                                                                                                                                                                      |
 | functionNames           | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | UUID of the symbol holding the string name of each function.                                                                                                                                                           |
 | symbolForwarding        | `std::map<gtirb::UUID, gtirb::UUID>`                                                               | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables.                                                                                   |
 | encodings               | `std::map<gtirb::UUID, std::string>`                                                               | Map from (typed) data objects to the encoding of the data, expressed as a `std::string` containing an assembler encoding specifier: "string", "uleb128" or "sleb128".                                                  |
 | sectionProperties    | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>`                                            | Map from section UUIDs to tuples with the ELF section type and flags.                                                                                                                                                     |
 | sectionIndex         | `std::map<uint64_t, gtirb::UUID>`                                                                  | Map from ELF section indices to section UUIDs.                                                                                                                                                                            |
 | elfSymbolInfo           | `std::map<gtirb::UUID, std::tuple<uint64_t, std::string, std::string, std::string, uint64_t>>`     | Map from symbol UUIDs to their ELF Symbol information containing the Size, Type, Binding, Visibility, and SectionIndex of the symbol.  Type can be "NOTYPE", "OBJECT", "FUNC", etc. Binding can be "LOCAL", "GLOBAL", or "WEAK". Visibility can be "DEFAULT", "HIDDEN", "PROTECTED", etc. For a complete list of possible values see e.g. https://refspecs.linuxbase.org/elf/gabi4+/ch4.symtab.html                                     |
 | elfSymbolTabIdxInfo     | `std::map<gtirb::UUID, std::vector<std::tuple<std::string, uint64_t>>>`                            | Map from symbol UUIDs to symbol section information including the names of the symbol tables where the symbol was declared (typically ".dynsym" or ".symtab") and the index within that table.                         |
 | elfSymbolVersions       | `std::map<gtirb::UUID, std::string>`                                                               | Map from symbol UUIDs to their ELF symbol version suffix if present. E.g. "@GLIBC_2.2.5".                                                                                                                              |
 | cfiDirectives           | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to vector of cfi directives. A cfi directive contains: a string describing the directive, a vector of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | libraries               | `std::vector<std::string>`                                                                         | Names of the libraries that are needed.                                                                                                                                                                                |
 | libraryPaths            | `std::vector<std::string>`                                                                         | Paths contained in the rpath of the binary.                                                                                                                                                                            |
 | padding                 | `std::map<gtirb::Offset, uint64_t>`                                                                | Offset of padding in a ByteInterval and the padding length in bytes.                                                                                                                                                   |
 | SCCs                    | `std::map<gtirb::UUID, int64_t>`                                                                   | The intra-procedural SCC identifier of each block                                                                                                                                                                      |
 | symbolicExpressionSizes | `std::map<gtirb::Offset, uint64_t>`                                                                | Map from an Offset of a symbolic expression in a ByteInterval to its extent, a size in bytes.                                                                                                                          |
 | peImportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string, std::string>>`                             | List of tuples detailing an imported function address, ordinal, function name, and library names for PE.                                                                                                               |
 | peExportEntries         | `std::vector<std::tuple<uint64_t, int64_t, std::string>>`                                          | List of tuples detailing an exported address, ordinal, and name for PE.                                                                                                                                                |
 | peImportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the imported symbols for PE.                                                                                                                                                                                  |
 | peExportedSymbols       | `std::vector<gtirb::UUID>`                                                                         | UUIDs of the exported symbols for PE.                                                                                                                                                                                  |
 | peResource              | `std::vector<std::tuple<std::vector<uint8_t>, gtirb::Offset, uint64_t>>`                           | List of PE resources. A resource header, data length, and data pointer.                                                                                                                                                |
 | souffleFacts            | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle facts by relation name to their associated type signatures and CSV.                                                                                                                                     |
 | souffleOutputs          | `std::map<std::string, std::tuple<std::string, std::string>>`                                      | Map of Souffle outputs by relation name to their associated type signatures and CSV.                                                                                                                                   |
 .
 ## Some References
 .
 1. [Datalog Disassembly](https://arxiv.org/abs/1906.03969)
 .
 2. [Souffle](https://github.com/souffle-lang/souffle)
 .
 3. [Capstone disassembler](http://www.capstone-engine.org/)
 .
 4. [Control Flow Integrity for COTS Binaries](http://seclab.cs.sunysb.edu/seclab/pubs/usenix13.pdf)
 .
 5. [Alias analysis for Assembly](http://reports-archive.adm.cs.cmu.edu/anon/anon/usr/ftp/2006/CMU-CS-06-180R.pdf)
 .
 6. [Reassembleable Disassembling](https://www.usenix.org/system/files/conference/usenixsecurity15/sec15-paper-wang-shuai.pdf)
 .
 7. [Ramblr: Making reassembly great again](https://pdfs.semanticscholar.org/dcf5/dc7e6ae2614dd0079b851e3f292148366ca8.pdf)
 .
 8. [An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_andriesse.pdf)
 .
 9. [Binary Code is Not Easy](https://dl.acm.org/citation.cfm?id=2931047)
 .
Maintainer: gtirb@grammatech.com
Version: 1.5.3-focal
Installed-Size: 1181084

Package: gtirb-pprinter
Version: 1.8.3-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter/gtirb-pprinter_1.8.3-focal_amd64.deb
Size: 2912
SHA256: 200b1b98d709bdd85a1b883d523156d5a590a673d4d0d9884d5bc3a113a13094
SHA1: 264815c981e64ef101f5b3e13ede24597058f66a
MD5sum: e585f760c7a6d48708e1f4b1ced54756
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
  GTIRB Pretty Printer
  ====================
  .
  A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
  intermediate representation for binary analysis and reverse
  engineering to gas-syntax assembly code.
  .
  .
  ## Building
  .
  The pretty-printer uses C++17, and requires a compiler which supports
  that standard such as gcc 7, clang 6, or MSVC 2017.
  .
  To build and install the pretty printer, the following requirements
  should be installed:
  .
  * [GTIRB](https://github.com/grammatech/gtirb).
  * [Capstone](http://www.capstone-engine.org/). At the moment
    we require our own fork https://github.com/GrammaTech/capstone/tree/next
    that contains some additional fixes (until new official releases are cut).
  * [Boost](https://www.boost.org/), version 1.67.0 or later.
    * Requires the libraries:
      * filesystem
      * program_options
      * system
    * Ubuntu 18 and earlier provide out of date versions;
      build from source on those Ubuntu versions.
  .
  Note that these versions are newer than what your package manager may provide
  by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
  these dependencies from sources to avoid versioning problems.
  .
  Use the following options to configure cmake:
  - You can tell CMake which compiler to use with
    `-DCMAKE_CXX_COMPILER=<compiler>`.
  - Normally CMake will find GTIRB automatically, but if it does not you
    can pass `-Dgtirb_DIR=<path-to-gtirb-build>`.
  - gtirb-pprinter can make use of GTIRB in static library form (instead of
    shared library form, the default) if you use the flag
    `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
  - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
    statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
  - You can configure CMake to use a custom location for Capstone by specifying
    `-DCMAKE_LIBRARY_PATH=<path-to-capstone>`.
  - You can use vcpkg on Windows to provide some dependencies by passing
    `-DCMAKE_TOOLCHAIN_FILE=<path-to-vcpkg\scripts\buildsystems\vcpkg.cmake>`.
  .
  Once the dependencies are installed, you can configure and build as follows:
  .
  ```sh
  cmake ./ -Bbuild
  cd build
  make
  ```
  .
  ## Installing
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
  .
  ## Usage
  .
  ### Generate reassembleable assembly code
  Pretty print the GTIRB for a simple hello world executable to an
  assembly file named `hello.S`, assemble this file with the GNU
  assembler to an object file named `hello.o`, and link this object file
  into an executable.
  .
  ```sh
  gtirb-pprinter hello.gtirb --asm hello.S
  as hello.S -o hello.o
  ld hello.o -o hello
  ./hello
  ```
  ### Generate a new binary
  The `--binary` flag to gtirb-pprinter generates a new binary by
  calling `gcc` directly.
  .
  ```sh
  gtirb-pprinter hello.gtirb --binary hello
  ```
  .
  This option admits an argument `--library-paths` or `-L` to
  specify additional paths where libraries might be located.
  .
  For example:
  ```sh
  gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
  ```
  .
  ## AuxData Used by the Pretty Printer
  .
  Generating assembly depends on a number of additional pieces of information
  beyond the symbols and instruction/data bytes in the IR. The pretty printer
  expects this information to be available in a number of
  [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
  objects stored with the IR. We document the expected keys along with the
  associated types and contents in this table.
  .
  | Key              | Type                                           | Purpose                                                                                                                              |
  |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
  | comments         | `std::map<gtirb::Offset, std::string>`           | Per-instruction or data element comments.                                                                                          |
  | functionEntries    | `std::map<gtirb::UUID, std::set<gtirb::UUID>>` | UUIDs of the blocks that are entry points of functions.                                                                                              |
  | symbolForwarding | `std::map<gtirb::UUID, gtirb::UUID>`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
  | encodings            | `std::map<gtirb::UUID,std::string>`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: "string", "uleb128" or "sleb128".     |
  | sectionProperties | `std::map<gtirb::UUID, std::tuple<uint64_t, uint64_t>>` | Map from section UUIDs to tuples with the section types and flags. |
  | cfiDirectives   | `std::map<gtirb::Offset, std::vector<std::tuple<std::string, std::vector<int64_t>, gtirb::UUID>>>` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
  | elfSymbolInfo | `std::map<gtirb::UUID, std::tuple<uint64_t, std::string, std::string, std::string, uint64_t>>` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
  .
  ## AuxData Used by the Binary Printer
  .
  In order to generate new binaries, gtirb-binary-printer also uses the following tables:
  .
  | Key              | Type                             | Purpose                                                                          |
  |------------------|----------------------------------|----------------------------------------------------------------------------------|
  | libraries        | `std::vector<std::string>`       | Names of the libraries that are needed.                                          |
  | libraryPaths     | `std::vector<std::string>`       | Paths contained in the rpath of the binary                                       |
  .
Depends: gtirb-pprinter-1.8.3 (= 1.8.3-focal)

Package: gtirb-pprinter-1.6.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.3 (>= 1.10.3-focal), libgtirb-1.10.3 (<< 2.0.0), libgtirb-pprinter-1.6.0 (= 1.6.0-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.1-gt3 (= 1:4.0.1-gt3)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-1.6.0/gtirb-pprinter-1.6.0_1.6.0-focal_amd64.deb
Size: 69076
SHA256: ea037de44819a310fc44629a03c5a7e30c06b687570110648eef0bbd0b8062d3
SHA1: 225bc712b23ecf1619425bd7437ae763ba8d4d4a
MD5sum: 40670f0c124acd3582a43e2e48408639
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0-focal or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.6.0-focal
Installed-Size: 339

Package: gtirb-pprinter-1.7.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.4 (=1.10.4-focal), libgtirb-pprinter-1.7.0 (=1.7.0-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-1.7.0/gtirb-pprinter-1.7.0_1.7.0-focal_amd64.deb
Size: 101460
SHA256: b77acd64feefe219476c96d1523430921b158d72c80b5f2e366005939935aaae
SHA1: 588199d378b6eed6ddafd1a617d08bef102bb058
MD5sum: 7a81f14ed9ad9a43aca9445d237342c8
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.7.0-focal
Installed-Size: 339

Package: gtirb-pprinter-1.8.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.5 (=1.10.5-focal), libgtirb-pprinter-1.8.0 (=1.8.0-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-1.8.0/gtirb-pprinter-1.8.0_1.8.0-focal_amd64.deb
Size: 102164
SHA256: 79305d05a0cf91471bd7cd9a7c106e111114b60957322939f153cf2cee8d46cd
SHA1: c60f85c7de9e95640923f23545d79e10be91dc87
MD5sum: 97145e99f6d696c4a48872555b383b15
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.0-focal
Installed-Size: 344

Package: gtirb-pprinter-1.8.2
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.6 (=1.10.6-focal), libgtirb-pprinter-1.8.2 (=1.8.2-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-4.0.2-gt1 (=1:4.0.2-gt1)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-1.8.2/gtirb-pprinter-1.8.2_1.8.2-focal_amd64.deb
Size: 104162
SHA256: d44e6152883b94397cf61f7f9ee9e7ec65f01ede750c363f513d8314f5ee2a5b
SHA1: d19e71c35dffcb5648e17cf3cf3cf7256e224993
MD5sum: 99e85ce16c94ae9893e69ca2c9dcdb0e
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.2-focal
Installed-Size: 354

Package: gtirb-pprinter-1.8.3
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.7 (=1.10.7-focal), libgtirb-pprinter-1.8.3 (=1.8.3-focal), libboost-filesystem1.71.0, libboost-program-options1.71.0, libcapstone-dev-5.0.0-gt2 (=1:5.0.0-gt2)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-1.8.3/gtirb-pprinter-1.8.3_1.8.3-focal_amd64.deb
Size: 104146
SHA256: 6253d9269122b74669cea347ed5219f11150cb07fbb558513cbf5b98d11415f7
SHA1: f5c28edcd91ae5802453ba9b9c2a2a83af239251
MD5sum: ff0bd3f9d19c8e6e924de94f7847cabb
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.3-focal
Installed-Size: 354

Package: gtirb-pprinter-dbg
Version: 1.8.3-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-dbg/gtirb-pprinter-dbg_1.8.3-focal_amd64.deb
Size: 2916
SHA256: 21bdeb797091b6645f7479867575feed4ad9d8895b5791c4b271a117e8ca75c0
SHA1: 071cb5cdb3403860b86bc0a562188ca01c40a458
MD5sum: aabc496007999c0b53aaac974897e9eb
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
  GTIRB Pretty Printer
  ====================
  .
  A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
  intermediate representation for binary analysis and reverse
  engineering to gas-syntax assembly code.
  .
  .
  ## Building
  .
  The pretty-printer uses C++17, and requires a compiler which supports
  that standard such as gcc 7, clang 6, or MSVC 2017.
  .
  To build and install the pretty printer, the following requirements
  should be installed:
  .
  * [GTIRB](https://github.com/grammatech/gtirb).
  * [Capstone](http://www.capstone-engine.org/). At the moment
    we require our own fork https://github.com/GrammaTech/capstone/tree/next
    that contains some additional fixes (until new official releases are cut).
  * [Boost](https://www.boost.org/), version 1.67.0 or later.
    * Requires the libraries:
      * filesystem
      * program_options
      * system
    * Ubuntu 18 and earlier provide out of date versions;
      build from source on those Ubuntu versions.
  .
  Note that these versions are newer than what your package manager may provide
  by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
  these dependencies from sources to avoid versioning problems.
  .
  Use the following options to configure cmake:
  - You can tell CMake which compiler to use with
    `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
  - Normally CMake will find GTIRB automatically, but if it does not you
    can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
  - gtirb-pprinter can make use of GTIRB in static library form (instead of
    shared library form, the default) if you use the flag
    `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
  - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
    statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
  - You can configure CMake to use a custom location for Capstone by specifying
    `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
  - You can use vcpkg on Windows to provide some dependencies by passing
    `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
  .
  Once the dependencies are installed, you can configure and build as follows:
  .
  ```sh
  cmake ./ -Bbuild
  cd build
  make
  ```
  .
  ## Installing
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
  .
  ## Usage
  .
  ### Generate reassembleable assembly code
  Pretty print the GTIRB for a simple hello world executable to an
  assembly file named `hello.S`, assemble this file with the GNU
  assembler to an object file named `hello.o`, and link this object file
  into an executable.
  .
  ```sh
  gtirb-pprinter hello.gtirb --asm hello.S
  as hello.S -o hello.o
  ld hello.o -o hello
  ./hello
  ```
  ### Generate a new binary
  The `--binary` flag to gtirb-pprinter generates a new binary by
  calling `gcc` directly.
  .
  ```sh
  gtirb-pprinter hello.gtirb --binary hello
  ```
  .
  This option admits an argument `--library-paths` or `-L` to
  specify additional paths where libraries might be located.
  .
  For example:
  ```sh
  gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
  ```
  .
  ## AuxData Used by the Pretty Printer
  .
  Generating assembly depends on a number of additional pieces of information
  beyond the symbols and instruction/data bytes in the IR. The pretty printer
  expects this information to be available in a number of
  [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
  objects stored with the IR. We document the expected keys along with the
  associated types and contents in this table.
  .
  | Key              | Type                                           | Purpose                                                                                                                              |
  |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
  | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
  | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
  | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
  | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
  | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
  | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
  | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
  .
  ## AuxData Used by the Binary Printer
  .
  In order to generate new binaries, gtirb-binary-printer also uses the following tables:
  .
  | Key              | Type                             | Purpose                                                                          |
  |------------------|----------------------------------|----------------------------------------------------------------------------------|
  | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
  | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
  .
Depends: gtirb-pprinter-dbg-1.8.3 (= 1.8.3-focal)

Package: gtirb-pprinter-dbg-1.6.0
Architecture: amd64
Depends: gtirb-pprinter-1.6.0 (= 1.6.0-focal)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-dbg-1.6.0/gtirb-pprinter-dbg-1.6.0_1.6.0-focal_amd64.deb
Size: 2120144
SHA256: e450b175c2f5831f10218de6db3bf9fe52cd7d76405203410b2a5333e1e4f2c9
SHA1: 2a98b83cb70c93faec15e1862be36a05db7d0f4e
MD5sum: f874064282845082e4add3044568193f
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0-focal or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.6.0-focal
Installed-Size: 24304

Package: gtirb-pprinter-dbg-1.7.0
Architecture: amd64
Depends: gtirb-pprinter-1.7.0 (=1.7.0-focal)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-dbg-1.7.0/gtirb-pprinter-dbg-1.7.0_1.7.0-focal_amd64.deb
Size: 3934056
SHA256: 5e8b8644d0ec9a98c91188585a882016411741bbcd4224fd526df0cd8a70fc03
SHA1: 51cf7ab03a305f01ee50b453fbba75619c75cc84
MD5sum: 422ee3e2a784f376d38d99a2adeb18b6
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.7.0-focal
Installed-Size: 24682

Package: gtirb-pprinter-dbg-1.8.0
Architecture: amd64
Depends: gtirb-pprinter-1.8.0 (=1.8.0-focal)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-dbg-1.8.0/gtirb-pprinter-dbg-1.8.0_1.8.0-focal_amd64.deb
Size: 3944978
SHA256: 37ab4e89d88cf4c95547718b74638b7c820d9be8a1328d7915f913ab02efa1d9
SHA1: a1f8e10432d8a1605500b39ee1bea0cd2417c302
MD5sum: 324a72f2d37771bc96cc029b3a2e993f
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.0-focal
Installed-Size: 24760

Package: gtirb-pprinter-dbg-1.8.2
Architecture: amd64
Depends: gtirb-pprinter-1.8.2 (=1.8.2-focal)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-dbg-1.8.2/gtirb-pprinter-dbg-1.8.2_1.8.2-focal_amd64.deb
Size: 3970074
SHA256: 47de5ce21ba62ffd18210300065f9e6bc270b678d012b4327bf8eaf03346c2e0
SHA1: fedc58d831ce7be4beaddf01f8bf241b41bfeb41
MD5sum: 53c673edbe207269aa3ebfa20a12457c
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.2-focal
Installed-Size: 24875

Package: gtirb-pprinter-dbg-1.8.3
Architecture: amd64
Depends: gtirb-pprinter-1.8.3 (=1.8.3-focal)
Priority: optional
Section: devel
Filename: pool/stable/g/gtirb-pprinter-dbg-1.8.3/gtirb-pprinter-dbg-1.8.3_1.8.3-focal_amd64.deb
Size: 3970764
SHA256: 0f8ae9e87e14a132c834d9dc7be70e8ef797a95b767a2d437ca396c59626b625
SHA1: a2160f0278bf0e64d28556491351d1f8feaa7b30
MD5sum: c970aa84a76612a72b4f5db127347d25
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.3-focal
Installed-Size: 24874

Package: libcapstone-dev
Version: 1:5.0.0-gt2
Architecture: amd64
Maintainer: bfairservice@grammatech.com
Priority: extra
Section: checkinstall
Filename: pool/stable/libc/libcapstone-dev/libcapstone-dev_5.0.0-gt2_amd64.deb
Size: 728
SHA256: 27a792f85acaa4cc7f4558e89c057a6f19fb6086e09cd02b9a3996627906cb4b
SHA1: abbc8195baf81ba1a2a52387960a1b114e36ba06
MD5sum: 74f013007876f947fe665e20c254a45b
Description: Package created with checkinstall 1.6.2
Depends: libcapstone-dev-5.0.0-gt2 (= 1:5.0.0-gt2)

Package: libcapstone-dev-4.0.1-gt3
Installed-Size: 28184
Maintainer: root@bfairservice-2108
Architecture: amd64
Version: 1:4.0.1-gt3
Provides: libcapstone-dev
Priority: extra
Section: checkinstall
Filename: pool/stable/libc/libcapstone-dev-4.0.1-gt3/libcapstone-dev-4.0.1-gt3_4.0.1-gt3_amd64.deb
Size: 2727496
SHA256: 60c37d99905cd20d98965d75b04ecb28b50f899ff25b3e343ef940955390085f
SHA1: de61cd0b8dd53872bba89ed87937082320c602ea
MD5sum: 776cbca1729d788fc85a8081905e878a
Description: Package created with checkinstall 1.6.2

Package: libcapstone-dev-4.0.2-gt0
Installed-Size: 28184
Maintainer: bfairservice@grammatech.com
Architecture: amd64
Version: 1:4.0.2-gt0
Provides: libcapstone-dev-4.0.2-gt0
Priority: extra
Section: checkinstall
Filename: pool/stable/libc/libcapstone-dev-4.0.2-gt0/libcapstone-dev-4.0.2-gt0_4.0.2-gt0_amd64.deb
Size: 2729852
SHA256: c0c316511de8d7462ba5024e73f44c6c58079347ab0ab5bfdfd43b2c45aa1ed7
SHA1: 60a51a451acc4cd8bb32a66ee38fd8bef5437ee6
MD5sum: 308c033467845bc7e388cc20c994c14d
Description: Package created with checkinstall 1.6.2

Package: libcapstone-dev-4.0.2-gt1
Installed-Size: 28188
Maintainer: bfairservice@grammatech.com
Architecture: amd64
Version: 1:4.0.2-gt1
Provides: libcapstone-dev-4.0.2-gt1
Priority: extra
Section: checkinstall
Filename: pool/stable/libc/libcapstone-dev-4.0.2-gt1/libcapstone-dev-4.0.2-gt1_4.0.2-gt1_amd64.deb
Size: 2741924
SHA256: 01df9635f1a2ac60dd282fd8b37d42bc0fe4d0aefccb122010d45a43540d5bf1
SHA1: 39e369c47fb883273af41ef8d6494fb432f4f188
MD5sum: 498aeca3566256bb104c8cfcad36afc5
Description: Package created with checkinstall 1.6.2

Package: libcapstone-dev-5.0.0-gt2
Installed-Size: 28216
Maintainer: bfairservice@grammatech.com
Architecture: amd64
Version: 1:5.0.0-gt2
Provides: libcapstone-dev-5.0.0-gt2
Priority: extra
Section: checkinstall
Filename: pool/stable/libc/libcapstone-dev-5.0.0-gt2/libcapstone-dev-5.0.0-gt2_5.0.0-gt2_amd64.deb
Size: 2727172
SHA256: 5a5d0f72f6c80813d3d2ef9fea62d9c0abb3ce8b2f12f3276468ff11150b6a46
SHA1: 16b5a0fd8285385292146618359660cf68d4546f
MD5sum: e75d0ba4f19e557bf5cd87b4f76950ba
Description: Package created with checkinstall 1.6.2

Package: libgtirb
Version: 1.10.7-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb/libgtirb_1.10.7-focal_amd64.deb
Size: 5120
SHA256: ee52f4452924b42bcc364e3631965a10bca92d3b08c80f51d8f1f16ff07b9dbf
SHA1: 2a368bc65dd9193a8897f18c412dd44f4448b172
MD5sum: 11363a066d863439eea8a40909b83380
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
  # GTIRB
  .
  The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
  machine code analysis and rewriting data structure.  It is intended to
  facilitate the communication of binary IR between programs performing
  binary disassembly, analysis, transformation, and pretty printing.
  GTIRB is modeled on LLVM-IR, and seeks to serve a similar
  functionality of encouraging communication and interoperability
  between tools.
  .
  The remainder of this file describes various aspects of GTIRB:
  - [Structure](#structure)
  - [Installing](#installing)
  - [Building](#building)
  - [Usage](#usage)
  .
  # Structure
  .
  GTIRB has the following structure.  Solid lines denote inheritance.
  Dotted lines denote reference by UUID.
  .
  ![GTIRB Data Structure](.gtirb.svg)
  .
  ## IR
  .
  An instance of GTIRB may include multiple modules (`Module`) which
  represent loadable objects such as executables or libraries, an
  inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
  (`AuxData`) which can hold arbitrary analysis results in user-defined
  formats which can easily reference other elements of the IR.  Each
  module holds information such as symbols (`Symbol`) and sections which
  themselves hold the actual bytes and data and code blocks of the
  module.  The CFG consists of basic blocks (`Block`) and control flow
  edges between these blocks.  Each data or code block references a
  range of bytes in a byte interval (`ByteInterval`).  A section may
  hold one large byte interval holding all blocks---if the relative
  positions of blocks in that section are defined---or may hold one byte
  interval per block---if the relative positions of blocks is not
  defined, e.g. for the code blocks in the `.text` section during
  program rewriting.  Each symbol holds a pointer to the block or datum
  it references.
  .
  .
  ## Instructions
  .
  GTIRB explicitly does NOT represent instructions or instruction
  semantics but does provide symbolic operand information and access to
  the bytes.  There are many *intermediate languages* (IL)s for
  representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
  [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
  or any other IL by storing instructions generally and efficiently as
  *raw machine-code bytes* and separately storing the symbolic and
  control flow information.  The popular [Capstone][]/[Keystone][]
  decoder/encoder provide an excellent option to read and write
  instructions from/to GTIRB&apos;s machine-code byte representation without
  committing to any particular semantic IL.  By supporting multiple ILs
  and separate storage of analysis results in auxiliary data tables
  GTIRB enables collaboration between independent binary analysis and
  rewriting teams and tools.
  .
  [BAP]: https://github.com/BinaryAnalysisPlatform/bap
  [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
  [Angr]: http://angr.io
  [Vex]: https://github.com/angr/pyvex
  [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
  [Capstone]: https://www.capstone-engine.org
  [Keystone]: https://www.keystone-engine.org
  .
  .
  ## Auxiliary Data
  .
  GTIRB provides for the sharing of additional information,
  e.g. analysis results, in the form of `AuxData` objects.  These can
  store maps and vectors of basic GTIRB types in a portable way. The
  [GTIRB manual][] describes the structure for common types of auxiliary
  data such as function boundary information, type information, or
  results of common analyses in [Standard AuxData Schemata][].
  .
  [GTIRB manual]: https://grammatech.github.io/gtirb/
  [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
  .
  .
  ## UUIDs
  .
  Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
  and blocks (`Block`)---has a universally unique identifier (UUID).
  UUIDs allow both first-class IR components and AuxData tables to
  reference elements of the IR.
  .
  Instructions and symbolic operands can be addressed by the class
  `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
  block) and an offset.
  .
  .
  # Installing
  .
  Packages currently existing for easily installing GTIRB (and attendant
  tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
  pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
  instructions.  Additionally, a public Docker image exists at
  [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
  versioned with Major.Minor.Patch versioning where Major version
  increments will require significant source changes but should be very
  rare, Minor version increments may require small source changes, and
  Patch version increments shouldn&apos;t break any downstream builds.  We do
  not yet provide ABI compatibility across any version changes.
  .
  [ddisasm]: https://github.com/GrammaTech/ddisasm
  [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
  [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
  .
  .
  ## Python API
  .
  The GTIRB Python API may be installed with the following.  Note
  however, that installation of the `ddisasm` and `gtirb-pprinter`
  packages as described below is recommended for use with every API.
  ```sh
  pip install gtirb
  ```
  .
  ## Windows
  .
  Pre-built debug and release binaries are available for Windows at:
  [windows-debug/][], and [windows-release/][].  A symbol server for the
  debugging symbols for both the release and debug binaries is available
  at [https://download.grammatech.com/gtirb/files/symbol-server/][].
  For information about how to use a symbol server with your debugger,
  please see [Specify_symbol_locations_and_loading_behavior][] or your
  debugger&apos;s documentation.
  .
  [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
  [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
  [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
  [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
  .
  .
  ## Ubuntu
  .
  Packages for Ubuntu 18 and 20 are available in the GTIRB apt repository and may
  be installed per the following instructions.
  .
  First, add GrammaTech&apos;s APT key.
  ```sh
  wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
  ```
  .
  Next update your sources.list file.
  ```sh
  echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
  ```
  Where:
  - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20
  respectively, and
  - `[component]` is either `stable`, which holds the last versioned release, or
  `unstable`, which holds the HEAD of the repository.
  .
  &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost
  &gt; package from a PPA.  You can add it like this: `add-apt-repository
  ppa:mhier/libboost-latest`
  .
  Finally update your package database and install the core GTIRB tools:
  ```sh
  sudo apt-get update
  sudo apt-get install libgtirb gtirb-pprinter ddisasm
  ```
  .
  **Warning**:  There is a problem with the packages in the stable repository
  that will cause conflicts if you try `apt-get upgrade`.  In this case,
  uninstall and reinstall the packages you got from the GTIRB repository.  You
  may need to use `dpkg --remove` to remove the metapackages (e.g. `ddisasm`)
  before removing the concrete versioned packages (e.g. `ddisasm-1.5.1`).
  .
  ## Arch Linux
  .
  The Arch User Repository ([AUR][]) includes packages for GTIRB:
  `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
  command will build and install all three packages using the popular
  [aur helper][] [yay][].
  ```sh
  yay ddisasm-git
  ```
  .
  [AUR]: https://aur.archlinux.org/
  [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
  [yay]: https://github.com/Jguer/yay
  .
  .
  # Building
  .
  GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
  and Visual Studio compilers supporting at least C++17.  GTIRB uses
  CMake which must be installed with at least version 3.10.
  .
  The common build process looks like this:
  ```sh
  mkdir build
  cd build
  # Note: You may wish to add some -D arguments to the next command. See below.
  cmake &lt;path/to/gtirb&gt;
  cmake --build .
  # Run the test suite.
  ctest
  ```
  .
  For customizing the GTIRB build, you can get a list of customization options by
  navigating to your build directory and running:
  .
  ```sh
  cmake -LH
  ```
  .
  ## Requirements
  .
  To build and install GTIRB, the following requirements should be installed:
  .
  - [CMake][], version 3.10.0 or higher.
     - Ubuntu 18 provides this version via the APT package `cmake`.
     - Ubuntu 16 and earlier provide out of date versions; build from
       source on those versions.
  - [Protobuf][], version
    3.0.0 or later.
    - Ubuntu 18 provides this version via the APT packages
      `libprotobuf-dev` and `protobuf-compiler`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
  - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
    - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
  .
  [CMake]: https://cmake.org/
  [Protobuf]: https://developers.google.com/protocol-buffers/
  [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
  .
  .
  # Usage
  .
  GTIRB is designed to be serialized using [Google protocol buffers][]
  (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
  .
  GTIRB may also be used through a dedicated API implemented in multiple
  languages. The APIs provide efficient data structures suitable for use
  by binary analysis and rewriting applications; see
  [below](#gtirb-api-implementations) for details.
  .
  [Google protocol buffers]: https://developers.google.com/protocol-buffers/
  [protobuf]: https://github.com/google/protobuf/wiki
  .
  .
  ## Using Serialized GTIRB Data
  .
  The serialized [protobuf][] data produced by GTIRB allows for
  exploration and manipulation in the language of your choice. The
  [Google protocol buffers][] homepage lists the languages in which
  protocol buffers can be used directly; users of other languages can
  convert the protobuf-formatted data to JSON format and then use the
  JSON data in their applications.
  .
  The `proto` directory in this repository contains the protocol buffer
  message type definitions for GTIRB. You can inspect these `.proto`
  files to determine the structure of the various GTIRB message
  types. The top-level message type is `IR`.
  .
  For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
  .
  .
  ## GTIRB API Implementations
  .
  The GTIRB API is currently available in C++, Python, and Common Lisp.
  There is a *partial* Java API which is not ready for external use.
  For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
  different API implementations, see:
  .
    - [C++ API](doc/cpp/README.md)
    - [Python API](python/README.md)
    - [Common Lisp API](cl/README.md)
    - Java API **incomplete**
  .
Depends: libgtirb-1.10.7 (= 1.10.7-focal)

Package: libgtirb-1.10.3
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libprotobuf17
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-1.10.3/libgtirb-1.10.3_1.10.3-focal_amd64.deb
Size: 228044
SHA256: 522219758f4e7b0341f5d69a15534f66199de48f412bb1d2ceffd4cbc22afecd
SHA1: e96efcdf4ea7950b9ed8c8de7bcc5e7aecc6da89
MD5sum: 2f2b88d78cc25aec73276f52d56040d1
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g.,
 [BAP](https://github.com/BinaryAnalysisPlatform/bap)&apos;s
 [BIL](https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf),
 [Angr](http://angr.io)&apos;s [Vex](https://github.com/angr/pyvex), or
 [Ghidra](https://www.nsa.gov/resources/everyone/ghidra/)&apos;s P-code).
 GTIRB works with these or any other IL by storing instructions
 generally and efficiently as *raw machine-code bytes* and separately
 storing the symbolic and control flow information.  The popular
 [Capstone](https://www.capstone-engine.org)/[Keystone](https://www.keystone-engine.org)
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual](https://grammatech.github.io/gtirb/) describes the
 structure for common types of auxiliary data such as function boundary
 information, type information, or results of common analyses in
 [Standard AuxData Schemata](https://grammatech.github.io/gtirb/md__aux_data.html).
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 # Installing
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm](https://github.com/GrammaTech/ddisasm)
 disassembler and
 [gtirb-pprinter](https://github.com/GrammaTech/gtirb-pprinter) pretty
 printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  GTIRB is versioned with Major.Minor.Patch versioning
 where Major version increments will require significant source changes
 but should be very rare, Minor version increments may require small
 source changes, and Patch version increments shouldn&apos;t break any
 downstream builds.  We do not yet provide ABI compatibility across any
 version changes.
 .
 ## Python API
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/](https://grammatech.github.io/gtirb/pkgs/windows-debug/),
 and
 [windows-release/](https://grammatech.github.io/gtirb/pkgs/windows-release/).
 A symbol server for the debugging symbols for both the release and
 debug binaries is available at
 [https://download.grammatech.com/gtirb/files/](https://download.grammatech.com/gtirb/files/).
 For information about how to use a symbol server with your debugger,
 please see
 [docs.microsoft.com#Specify_symbol_locations_and_loading_behavior](https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior)
 or your debugger&apos;s documentation.
 .
 ## Ubuntu
 Packages for Ubuntu 16, 18, and 20 are available in the GTIRB apt
 repository.  The GTIRB package has some dependencies which are only
 available in other PPAs.  You will have to add these PPAs to your
 system in order to install the GTIRB package.
 .
 Instructions for adding the appropriate PPAS and installing GTIRB on each
 platform follow.
 .
 ### Ubuntu16
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb https://grammatech.github.io/gtirb/pkgs/xenial ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install --allow-unauthenticated libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu18
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu20
 ```sh
 sudo apt-get install software-properties-common
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/focal ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 Arch packages are available for download from
 [https://grammatech.github.io/gtirb/pkgs/arch/](https://grammatech.github.io/gtirb/pkgs/arch/)
 and may be directly installed with `pacman`.
 .
 Additionally, the Arch User Repository (AUR) https://aur.archlinux.org/ has packages
 for GTIRB (`gtirb-git`) the GTIRB Pretty Printer
 (`gtirb-pprinter-git`) and the datalog disassembler (`ddisasm-git`).
 Note that installing `ddisasm-git` will cause the other two packages
 to be installed as well given that they are both dependencies.
 .
 The following command will build and install GTIRB using the popular
 [aur helper](https://wiki.archlinux.org/index.php/AUR_helpers)
 [yay](https://github.com/Jguer/yay).
 ```sh
 yay gtirb-git
 ```
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake](https://cmake.org/), version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf](https://developers.google.com/protocol-buffers/), version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)](https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest), version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google&apos;s protocol;buffers](https://developers.google.com/protocol-buffers/) (i.e.,
 [protobuf](https://github.com/google/protobuf/wiki)), enabling
 [easy and efficient use from any programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf](https://github.com/google/protobuf/wiki)
 data produced by GTIRB allows for exploration and manipulation in the
 language of your choice. The [Google protocol;buffers](https://developers.google.com/protocol-buffers/) homepage
 lists the languages in which protocol buffers can be used directly;
 users of other languages can convert the protobuf-formatted data to
 JSON format and then use the JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.3-focal
Installed-Size: 1978

Package: libgtirb-1.10.4
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libprotobuf17
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-1.10.4/libgtirb-1.10.4_1.10.4-focal_amd64.deb
Size: 331082
SHA256: 05efa17c6211a4d8ecd0624ca77a669389d8d1e50781665b578a1098a25bb721
SHA1: 66769a1d3453b2ec7310220b4f59c2a8fb77a29a
MD5sum: da9e39d13091fcdb70a043037edaec01
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.4-focal
Installed-Size: 1986

Package: libgtirb-1.10.5
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libprotobuf17
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-1.10.5/libgtirb-1.10.5_1.10.5-focal_amd64.deb
Size: 331204
SHA256: 4460b39d40def51c2f7afd716dc3adb39a490c30b15ead04c0f73f0308868197
SHA1: d8a21c5daf2f08590302c45b74574de0d53dd7a7
MD5sum: b1cc8baa57779b651f1ecea88b173133
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.5-focal
Installed-Size: 1986

Package: libgtirb-1.10.6
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libprotobuf17
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-1.10.6/libgtirb-1.10.6_1.10.6-focal_amd64.deb
Size: 331204
SHA256: bc90e2e61f4dd66873738fd20272cf65e3331e9ddb4c75357898827a9d4fe5fd
SHA1: 50a32cef58ab4ee4f1cb9d40c0c0fd862fc054c1
MD5sum: 259a96150f2eaa3d65fb2a49cce8c15a
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.6-focal
Installed-Size: 1986

Package: libgtirb-1.10.7
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libprotobuf17
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-1.10.7/libgtirb-1.10.7_1.10.7-focal_amd64.deb
Size: 340252
SHA256: 61fa53ebb1244844e01a6ce7e51fba881d31cfae0c9dba8481de09bd37a8ec4b
SHA1: ac93f783822792903881a42607126c44133f1944
MD5sum: 2223d4c3e2263fbbdd177f271f6d05ad
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt repository and may
 be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20
 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or
 `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost
 &gt; package from a PPA.  You can add it like this: `add-apt-repository
 ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 **Warning**:  There is a problem with the packages in the stable repository
 that will cause conflicts if you try `apt-get upgrade`.  In this case,
 uninstall and reinstall the packages you got from the GTIRB repository.  You
 may need to use `dpkg --remove` to remove the metapackages (e.g. `ddisasm`)
 before removing the concrete versioned packages (e.g. `ddisasm-1.5.1`).
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.7-focal
Installed-Size: 2022

Package: libgtirb-dbg
Version: 1.10.7-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dbg/libgtirb-dbg_1.10.7-focal_amd64.deb
Size: 5124
SHA256: c4a456a625b8314745fc562072f700ca6b58ad8faf0796795a21c17efadfedcb
SHA1: 4324a5351982214219b16b45bcba5afb8dee2971
MD5sum: 09d6bc854f0ce43a150ab61543cf6cec
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
  # GTIRB
  .
  The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
  machine code analysis and rewriting data structure.  It is intended to
  facilitate the communication of binary IR between programs performing
  binary disassembly, analysis, transformation, and pretty printing.
  GTIRB is modeled on LLVM-IR, and seeks to serve a similar
  functionality of encouraging communication and interoperability
  between tools.
  .
  The remainder of this file describes various aspects of GTIRB:
  - [Structure](#structure)
  - [Installing](#installing)
  - [Building](#building)
  - [Usage](#usage)
  .
  # Structure
  .
  GTIRB has the following structure.  Solid lines denote inheritance.
  Dotted lines denote reference by UUID.
  .
  ![GTIRB Data Structure](.gtirb.svg)
  .
  ## IR
  .
  An instance of GTIRB may include multiple modules (`Module`) which
  represent loadable objects such as executables or libraries, an
  inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
  (`AuxData`) which can hold arbitrary analysis results in user-defined
  formats which can easily reference other elements of the IR.  Each
  module holds information such as symbols (`Symbol`) and sections which
  themselves hold the actual bytes and data and code blocks of the
  module.  The CFG consists of basic blocks (`Block`) and control flow
  edges between these blocks.  Each data or code block references a
  range of bytes in a byte interval (`ByteInterval`).  A section may
  hold one large byte interval holding all blocks---if the relative
  positions of blocks in that section are defined---or may hold one byte
  interval per block---if the relative positions of blocks is not
  defined, e.g. for the code blocks in the `.text` section during
  program rewriting.  Each symbol holds a pointer to the block or datum
  it references.
  .
  .
  ## Instructions
  .
  GTIRB explicitly does NOT represent instructions or instruction
  semantics but does provide symbolic operand information and access to
  the bytes.  There are many *intermediate languages* (IL)s for
  representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
  [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
  or any other IL by storing instructions generally and efficiently as
  *raw machine-code bytes* and separately storing the symbolic and
  control flow information.  The popular [Capstone][]/[Keystone][]
  decoder/encoder provide an excellent option to read and write
  instructions from/to GTIRB&apos;s machine-code byte representation without
  committing to any particular semantic IL.  By supporting multiple ILs
  and separate storage of analysis results in auxiliary data tables
  GTIRB enables collaboration between independent binary analysis and
  rewriting teams and tools.
  .
  [BAP]: https://github.com/BinaryAnalysisPlatform/bap
  [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
  [Angr]: http://angr.io
  [Vex]: https://github.com/angr/pyvex
  [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
  [Capstone]: https://www.capstone-engine.org
  [Keystone]: https://www.keystone-engine.org
  .
  .
  ## Auxiliary Data
  .
  GTIRB provides for the sharing of additional information,
  e.g. analysis results, in the form of `AuxData` objects.  These can
  store maps and vectors of basic GTIRB types in a portable way. The
  [GTIRB manual][] describes the structure for common types of auxiliary
  data such as function boundary information, type information, or
  results of common analyses in [Standard AuxData Schemata][].
  .
  [GTIRB manual]: https://grammatech.github.io/gtirb/
  [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
  .
  .
  ## UUIDs
  .
  Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
  and blocks (`Block`)---has a universally unique identifier (UUID).
  UUIDs allow both first-class IR components and AuxData tables to
  reference elements of the IR.
  .
  Instructions and symbolic operands can be addressed by the class
  `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
  block) and an offset.
  .
  .
  # Installing
  .
  Packages currently existing for easily installing GTIRB (and attendant
  tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
  pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
  instructions.  Additionally, a public Docker image exists at
  [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
  versioned with Major.Minor.Patch versioning where Major version
  increments will require significant source changes but should be very
  rare, Minor version increments may require small source changes, and
  Patch version increments shouldn&apos;t break any downstream builds.  We do
  not yet provide ABI compatibility across any version changes.
  .
  [ddisasm]: https://github.com/GrammaTech/ddisasm
  [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
  [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
  .
  .
  ## Python API
  .
  The GTIRB Python API may be installed with the following.  Note
  however, that installation of the `ddisasm` and `gtirb-pprinter`
  packages as described below is recommended for use with every API.
  ```sh
  pip install gtirb
  ```
  .
  ## Windows
  .
  Pre-built debug and release binaries are available for Windows at:
  [windows-debug/][], and [windows-release/][].  A symbol server for the
  debugging symbols for both the release and debug binaries is available
  at [https://download.grammatech.com/gtirb/files/symbol-server/][].
  For information about how to use a symbol server with your debugger,
  please see [Specify_symbol_locations_and_loading_behavior][] or your
  debugger&apos;s documentation.
  .
  [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
  [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
  [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
  [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
  .
  .
  ## Ubuntu
  .
  Packages for Ubuntu 18 and 20 are available in the GTIRB apt repository and may
  be installed per the following instructions.
  .
  First, add GrammaTech&apos;s APT key.
  ```sh
  wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
  ```
  .
  Next update your sources.list file.
  ```sh
  echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
  ```
  Where:
  - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20
  respectively, and
  - `[component]` is either `stable`, which holds the last versioned release, or
  `unstable`, which holds the HEAD of the repository.
  .
  &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost
  &gt; package from a PPA.  You can add it like this: `add-apt-repository
  ppa:mhier/libboost-latest`
  .
  Finally update your package database and install the core GTIRB tools:
  ```sh
  sudo apt-get update
  sudo apt-get install libgtirb gtirb-pprinter ddisasm
  ```
  .
  **Warning**:  There is a problem with the packages in the stable repository
  that will cause conflicts if you try `apt-get upgrade`.  In this case,
  uninstall and reinstall the packages you got from the GTIRB repository.  You
  may need to use `dpkg --remove` to remove the metapackages (e.g. `ddisasm`)
  before removing the concrete versioned packages (e.g. `ddisasm-1.5.1`).
  .
  ## Arch Linux
  .
  The Arch User Repository ([AUR][]) includes packages for GTIRB:
  `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
  command will build and install all three packages using the popular
  [aur helper][] [yay][].
  ```sh
  yay ddisasm-git
  ```
  .
  [AUR]: https://aur.archlinux.org/
  [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
  [yay]: https://github.com/Jguer/yay
  .
  .
  # Building
  .
  GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
  and Visual Studio compilers supporting at least C++17.  GTIRB uses
  CMake which must be installed with at least version 3.10.
  .
  The common build process looks like this:
  ```sh
  mkdir build
  cd build
  # Note: You may wish to add some -D arguments to the next command. See below.
  cmake &lt;path/to/gtirb&gt;
  cmake --build .
  # Run the test suite.
  ctest
  ```
  .
  For customizing the GTIRB build, you can get a list of customization options by
  navigating to your build directory and running:
  .
  ```sh
  cmake -LH
  ```
  .
  ## Requirements
  .
  To build and install GTIRB, the following requirements should be installed:
  .
  - [CMake][], version 3.10.0 or higher.
     - Ubuntu 18 provides this version via the APT package `cmake`.
     - Ubuntu 16 and earlier provide out of date versions; build from
       source on those versions.
  - [Protobuf][], version
    3.0.0 or later.
    - Ubuntu 18 provides this version via the APT packages
      `libprotobuf-dev` and `protobuf-compiler`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
  - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
    - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
  .
  [CMake]: https://cmake.org/
  [Protobuf]: https://developers.google.com/protocol-buffers/
  [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
  .
  .
  # Usage
  .
  GTIRB is designed to be serialized using [Google protocol buffers][]
  (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
  .
  GTIRB may also be used through a dedicated API implemented in multiple
  languages. The APIs provide efficient data structures suitable for use
  by binary analysis and rewriting applications; see
  [below](#gtirb-api-implementations) for details.
  .
  [Google protocol buffers]: https://developers.google.com/protocol-buffers/
  [protobuf]: https://github.com/google/protobuf/wiki
  .
  .
  ## Using Serialized GTIRB Data
  .
  The serialized [protobuf][] data produced by GTIRB allows for
  exploration and manipulation in the language of your choice. The
  [Google protocol buffers][] homepage lists the languages in which
  protocol buffers can be used directly; users of other languages can
  convert the protobuf-formatted data to JSON format and then use the
  JSON data in their applications.
  .
  The `proto` directory in this repository contains the protocol buffer
  message type definitions for GTIRB. You can inspect these `.proto`
  files to determine the structure of the various GTIRB message
  types. The top-level message type is `IR`.
  .
  For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
  .
  .
  ## GTIRB API Implementations
  .
  The GTIRB API is currently available in C++, Python, and Common Lisp.
  There is a *partial* Java API which is not ready for external use.
  For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
  different API implementations, see:
  .
    - [C++ API](doc/cpp/README.md)
    - [Python API](python/README.md)
    - [Common Lisp API](cl/README.md)
    - Java API **incomplete**
  .
Depends: libgtirb-dbg-1.10.7 (= 1.10.7-focal)

Package: libgtirb-dbg-1.10.3
Architecture: amd64
Depends: libgtirb-1.10.3 (= 1.10.3-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dbg-1.10.3/libgtirb-dbg-1.10.3_1.10.3-focal_amd64.deb
Size: 5870948
SHA256: 0239b7eb90e2a60c2819425ddfc494428e63810ee2b5bc49712b2912bfdb7a88
SHA1: d337b9e01f9dc3d411698c78a3f81dbbe27e707d
MD5sum: cb61d3d80f40b73f7700d69ac82df685
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g.,
 [BAP](https://github.com/BinaryAnalysisPlatform/bap)&apos;s
 [BIL](https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf),
 [Angr](http://angr.io)&apos;s [Vex](https://github.com/angr/pyvex), or
 [Ghidra](https://www.nsa.gov/resources/everyone/ghidra/)&apos;s P-code).
 GTIRB works with these or any other IL by storing instructions
 generally and efficiently as *raw machine-code bytes* and separately
 storing the symbolic and control flow information.  The popular
 [Capstone](https://www.capstone-engine.org)/[Keystone](https://www.keystone-engine.org)
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual](https://grammatech.github.io/gtirb/) describes the
 structure for common types of auxiliary data such as function boundary
 information, type information, or results of common analyses in
 [Standard AuxData Schemata](https://grammatech.github.io/gtirb/md__aux_data.html).
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 # Installing
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm](https://github.com/GrammaTech/ddisasm)
 disassembler and
 [gtirb-pprinter](https://github.com/GrammaTech/gtirb-pprinter) pretty
 printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  GTIRB is versioned with Major.Minor.Patch versioning
 where Major version increments will require significant source changes
 but should be very rare, Minor version increments may require small
 source changes, and Patch version increments shouldn&apos;t break any
 downstream builds.  We do not yet provide ABI compatibility across any
 version changes.
 .
 ## Python API
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/](https://grammatech.github.io/gtirb/pkgs/windows-debug/),
 and
 [windows-release/](https://grammatech.github.io/gtirb/pkgs/windows-release/).
 A symbol server for the debugging symbols for both the release and
 debug binaries is available at
 [https://download.grammatech.com/gtirb/files/](https://download.grammatech.com/gtirb/files/).
 For information about how to use a symbol server with your debugger,
 please see
 [docs.microsoft.com#Specify_symbol_locations_and_loading_behavior](https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior)
 or your debugger&apos;s documentation.
 .
 ## Ubuntu
 Packages for Ubuntu 16, 18, and 20 are available in the GTIRB apt
 repository.  The GTIRB package has some dependencies which are only
 available in other PPAs.  You will have to add these PPAs to your
 system in order to install the GTIRB package.
 .
 Instructions for adding the appropriate PPAS and installing GTIRB on each
 platform follow.
 .
 ### Ubuntu16
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb https://grammatech.github.io/gtirb/pkgs/xenial ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install --allow-unauthenticated libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu18
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu20
 ```sh
 sudo apt-get install software-properties-common
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/focal ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 Arch packages are available for download from
 [https://grammatech.github.io/gtirb/pkgs/arch/](https://grammatech.github.io/gtirb/pkgs/arch/)
 and may be directly installed with `pacman`.
 .
 Additionally, the Arch User Repository (AUR) https://aur.archlinux.org/ has packages
 for GTIRB (`gtirb-git`) the GTIRB Pretty Printer
 (`gtirb-pprinter-git`) and the datalog disassembler (`ddisasm-git`).
 Note that installing `ddisasm-git` will cause the other two packages
 to be installed as well given that they are both dependencies.
 .
 The following command will build and install GTIRB using the popular
 [aur helper](https://wiki.archlinux.org/index.php/AUR_helpers)
 [yay](https://github.com/Jguer/yay).
 ```sh
 yay gtirb-git
 ```
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake](https://cmake.org/), version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf](https://developers.google.com/protocol-buffers/), version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)](https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest), version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google&apos;s protocol;buffers](https://developers.google.com/protocol-buffers/) (i.e.,
 [protobuf](https://github.com/google/protobuf/wiki)), enabling
 [easy and efficient use from any programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf](https://github.com/google/protobuf/wiki)
 data produced by GTIRB allows for exploration and manipulation in the
 language of your choice. The [Google protocol;buffers](https://developers.google.com/protocol-buffers/) homepage
 lists the languages in which protocol buffers can be used directly;
 users of other languages can convert the protobuf-formatted data to
 JSON format and then use the JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.3-focal
Installed-Size: 36129

Package: libgtirb-dbg-1.10.4
Architecture: amd64
Depends: libgtirb-1.10.4 (=1.10.4-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dbg-1.10.4/libgtirb-dbg-1.10.4_1.10.4-focal_amd64.deb
Size: 9711284
SHA256: 3893ea5932a000b8b5927b99dad2e0563c7c657306adbbfce45a81e55485b8ab
SHA1: fa1dd145cf2a6a83f2a72bb86ae83db2acea2564
MD5sum: a116b2b02ef46cbcbcfe85ea07dc4cca
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.4-focal
Installed-Size: 36393

Package: libgtirb-dbg-1.10.5
Architecture: amd64
Depends: libgtirb-1.10.5 (=1.10.5-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dbg-1.10.5/libgtirb-dbg-1.10.5_1.10.5-focal_amd64.deb
Size: 9713332
SHA256: df22cf5b788cf9cd47f4177f75ecfbddb951ee81562d32fa5ce5be6ec47d518a
SHA1: 3aef87770dc953d92e1f062b66f0d00a53874d75
MD5sum: 0d35e9e65bbf3814c1f5d697eb3e8818
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.5-focal
Installed-Size: 36395

Package: libgtirb-dbg-1.10.6
Architecture: amd64
Depends: libgtirb-1.10.6 (=1.10.6-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dbg-1.10.6/libgtirb-dbg-1.10.6_1.10.6-focal_amd64.deb
Size: 9713256
SHA256: e83d1c98d86bf20793c9515804abdccbecbb09ab46d7ac00d8df2e7d7458ba93
SHA1: 21034877cd89bb6aa97f032b690d7747ea9ecd79
MD5sum: 5525228f5f98f5c4f46f5ec7363a9d97
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.6-focal
Installed-Size: 36396

Package: libgtirb-dbg-1.10.7
Architecture: amd64
Depends: libgtirb-1.10.7 (=1.10.7-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dbg-1.10.7/libgtirb-dbg-1.10.7_1.10.7-focal_amd64.deb
Size: 11871252
SHA256: 921df58a68e00cacf77c75f8b75d14cc3617214a9ac008a0a7fe5440a0f41c19
SHA1: 15b9f346a5c9c07deb9cd1d46b0fe5468c0b56b7
MD5sum: 0d190e1731ae7ab8295217c32a73dc6c
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt repository and may
 be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20
 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or
 `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost
 &gt; package from a PPA.  You can add it like this: `add-apt-repository
 ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 **Warning**:  There is a problem with the packages in the stable repository
 that will cause conflicts if you try `apt-get upgrade`.  In this case,
 uninstall and reinstall the packages you got from the GTIRB repository.  You
 may need to use `dpkg --remove` to remove the metapackages (e.g. `ddisasm`)
 before removing the concrete versioned packages (e.g. `ddisasm-1.5.1`).
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.7-focal
Installed-Size: 41292

Package: libgtirb-dev
Version: 1.10.7-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dev/libgtirb-dev_1.10.7-focal_amd64.deb
Size: 5124
SHA256: 9aa85a671d5a8c4f4d77aa8a29455ac58030768631f3b8943818ec5ef40bf3b8
SHA1: e076e1a301b7743139728932c038761f46db71c7
MD5sum: 8bbd94a8fd00b244ba3f9704305be4b8
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
  # GTIRB
  .
  The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
  machine code analysis and rewriting data structure.  It is intended to
  facilitate the communication of binary IR between programs performing
  binary disassembly, analysis, transformation, and pretty printing.
  GTIRB is modeled on LLVM-IR, and seeks to serve a similar
  functionality of encouraging communication and interoperability
  between tools.
  .
  The remainder of this file describes various aspects of GTIRB:
  - [Structure](#structure)
  - [Installing](#installing)
  - [Building](#building)
  - [Usage](#usage)
  .
  # Structure
  .
  GTIRB has the following structure.  Solid lines denote inheritance.
  Dotted lines denote reference by UUID.
  .
  ![GTIRB Data Structure](.gtirb.svg)
  .
  ## IR
  .
  An instance of GTIRB may include multiple modules (`Module`) which
  represent loadable objects such as executables or libraries, an
  inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
  (`AuxData`) which can hold arbitrary analysis results in user-defined
  formats which can easily reference other elements of the IR.  Each
  module holds information such as symbols (`Symbol`) and sections which
  themselves hold the actual bytes and data and code blocks of the
  module.  The CFG consists of basic blocks (`Block`) and control flow
  edges between these blocks.  Each data or code block references a
  range of bytes in a byte interval (`ByteInterval`).  A section may
  hold one large byte interval holding all blocks---if the relative
  positions of blocks in that section are defined---or may hold one byte
  interval per block---if the relative positions of blocks is not
  defined, e.g. for the code blocks in the `.text` section during
  program rewriting.  Each symbol holds a pointer to the block or datum
  it references.
  .
  .
  ## Instructions
  .
  GTIRB explicitly does NOT represent instructions or instruction
  semantics but does provide symbolic operand information and access to
  the bytes.  There are many *intermediate languages* (IL)s for
  representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
  [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
  or any other IL by storing instructions generally and efficiently as
  *raw machine-code bytes* and separately storing the symbolic and
  control flow information.  The popular [Capstone][]/[Keystone][]
  decoder/encoder provide an excellent option to read and write
  instructions from/to GTIRB&apos;s machine-code byte representation without
  committing to any particular semantic IL.  By supporting multiple ILs
  and separate storage of analysis results in auxiliary data tables
  GTIRB enables collaboration between independent binary analysis and
  rewriting teams and tools.
  .
  [BAP]: https://github.com/BinaryAnalysisPlatform/bap
  [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
  [Angr]: http://angr.io
  [Vex]: https://github.com/angr/pyvex
  [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
  [Capstone]: https://www.capstone-engine.org
  [Keystone]: https://www.keystone-engine.org
  .
  .
  ## Auxiliary Data
  .
  GTIRB provides for the sharing of additional information,
  e.g. analysis results, in the form of `AuxData` objects.  These can
  store maps and vectors of basic GTIRB types in a portable way. The
  [GTIRB manual][] describes the structure for common types of auxiliary
  data such as function boundary information, type information, or
  results of common analyses in [Standard AuxData Schemata][].
  .
  [GTIRB manual]: https://grammatech.github.io/gtirb/
  [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
  .
  .
  ## UUIDs
  .
  Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
  and blocks (`Block`)---has a universally unique identifier (UUID).
  UUIDs allow both first-class IR components and AuxData tables to
  reference elements of the IR.
  .
  Instructions and symbolic operands can be addressed by the class
  `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
  block) and an offset.
  .
  .
  # Installing
  .
  Packages currently existing for easily installing GTIRB (and attendant
  tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
  pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
  instructions.  Additionally, a public Docker image exists at
  [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
  versioned with Major.Minor.Patch versioning where Major version
  increments will require significant source changes but should be very
  rare, Minor version increments may require small source changes, and
  Patch version increments shouldn&apos;t break any downstream builds.  We do
  not yet provide ABI compatibility across any version changes.
  .
  [ddisasm]: https://github.com/GrammaTech/ddisasm
  [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
  [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
  .
  .
  ## Python API
  .
  The GTIRB Python API may be installed with the following.  Note
  however, that installation of the `ddisasm` and `gtirb-pprinter`
  packages as described below is recommended for use with every API.
  ```sh
  pip install gtirb
  ```
  .
  ## Windows
  .
  Pre-built debug and release binaries are available for Windows at:
  [windows-debug/][], and [windows-release/][].  A symbol server for the
  debugging symbols for both the release and debug binaries is available
  at [https://download.grammatech.com/gtirb/files/symbol-server/][].
  For information about how to use a symbol server with your debugger,
  please see [Specify_symbol_locations_and_loading_behavior][] or your
  debugger&apos;s documentation.
  .
  [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
  [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
  [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
  [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
  .
  .
  ## Ubuntu
  .
  Packages for Ubuntu 18 and 20 are available in the GTIRB apt repository and may
  be installed per the following instructions.
  .
  First, add GrammaTech&apos;s APT key.
  ```sh
  wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
  ```
  .
  Next update your sources.list file.
  ```sh
  echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
  ```
  Where:
  - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20
  respectively, and
  - `[component]` is either `stable`, which holds the last versioned release, or
  `unstable`, which holds the HEAD of the repository.
  .
  &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost
  &gt; package from a PPA.  You can add it like this: `add-apt-repository
  ppa:mhier/libboost-latest`
  .
  Finally update your package database and install the core GTIRB tools:
  ```sh
  sudo apt-get update
  sudo apt-get install libgtirb gtirb-pprinter ddisasm
  ```
  .
  **Warning**:  There is a problem with the packages in the stable repository
  that will cause conflicts if you try `apt-get upgrade`.  In this case,
  uninstall and reinstall the packages you got from the GTIRB repository.  You
  may need to use `dpkg --remove` to remove the metapackages (e.g. `ddisasm`)
  before removing the concrete versioned packages (e.g. `ddisasm-1.5.1`).
  .
  ## Arch Linux
  .
  The Arch User Repository ([AUR][]) includes packages for GTIRB:
  `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
  command will build and install all three packages using the popular
  [aur helper][] [yay][].
  ```sh
  yay ddisasm-git
  ```
  .
  [AUR]: https://aur.archlinux.org/
  [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
  [yay]: https://github.com/Jguer/yay
  .
  .
  # Building
  .
  GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
  and Visual Studio compilers supporting at least C++17.  GTIRB uses
  CMake which must be installed with at least version 3.10.
  .
  The common build process looks like this:
  ```sh
  mkdir build
  cd build
  # Note: You may wish to add some -D arguments to the next command. See below.
  cmake &lt;path/to/gtirb&gt;
  cmake --build .
  # Run the test suite.
  ctest
  ```
  .
  For customizing the GTIRB build, you can get a list of customization options by
  navigating to your build directory and running:
  .
  ```sh
  cmake -LH
  ```
  .
  ## Requirements
  .
  To build and install GTIRB, the following requirements should be installed:
  .
  - [CMake][], version 3.10.0 or higher.
     - Ubuntu 18 provides this version via the APT package `cmake`.
     - Ubuntu 16 and earlier provide out of date versions; build from
       source on those versions.
  - [Protobuf][], version
    3.0.0 or later.
    - Ubuntu 18 provides this version via the APT packages
      `libprotobuf-dev` and `protobuf-compiler`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
  - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
    - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
  .
  [CMake]: https://cmake.org/
  [Protobuf]: https://developers.google.com/protocol-buffers/
  [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
  .
  .
  # Usage
  .
  GTIRB is designed to be serialized using [Google protocol buffers][]
  (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
  .
  GTIRB may also be used through a dedicated API implemented in multiple
  languages. The APIs provide efficient data structures suitable for use
  by binary analysis and rewriting applications; see
  [below](#gtirb-api-implementations) for details.
  .
  [Google protocol buffers]: https://developers.google.com/protocol-buffers/
  [protobuf]: https://github.com/google/protobuf/wiki
  .
  .
  ## Using Serialized GTIRB Data
  .
  The serialized [protobuf][] data produced by GTIRB allows for
  exploration and manipulation in the language of your choice. The
  [Google protocol buffers][] homepage lists the languages in which
  protocol buffers can be used directly; users of other languages can
  convert the protobuf-formatted data to JSON format and then use the
  JSON data in their applications.
  .
  The `proto` directory in this repository contains the protocol buffer
  message type definitions for GTIRB. You can inspect these `.proto`
  files to determine the structure of the various GTIRB message
  types. The top-level message type is `IR`.
  .
  For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
  .
  .
  ## GTIRB API Implementations
  .
  The GTIRB API is currently available in C++, Python, and Common Lisp.
  There is a *partial* Java API which is not ready for external use.
  For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
  different API implementations, see:
  .
    - [C++ API](doc/cpp/README.md)
    - [Python API](python/README.md)
    - [Common Lisp API](cl/README.md)
    - Java API **incomplete**
  .
Depends: libgtirb-dev-1.10.7 (= 1.10.7-focal)

Package: libgtirb-dev-1.10.3
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.3 (= 1.10.3-focal), libboost-dev (>= 1.67) | libboost1.67-dev, libprotobuf-dev (>= 3.6.1~), libprotobuf-dev (<< 3.6.2)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dev-1.10.3/libgtirb-dev-1.10.3_1.10.3-focal_amd64.deb
Size: 2559752
SHA256: 7c410c402072a3366f0fd9f4d4a88166ea36a7ac7f1453e6cbc5ceee520a5607
SHA1: 593df493fabf71e61f24fa8b9533bb34abe56aeb
MD5sum: 28c4399fc549ca7fb47683d524543f36
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g.,
 [BAP](https://github.com/BinaryAnalysisPlatform/bap)&apos;s
 [BIL](https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf),
 [Angr](http://angr.io)&apos;s [Vex](https://github.com/angr/pyvex), or
 [Ghidra](https://www.nsa.gov/resources/everyone/ghidra/)&apos;s P-code).
 GTIRB works with these or any other IL by storing instructions
 generally and efficiently as *raw machine-code bytes* and separately
 storing the symbolic and control flow information.  The popular
 [Capstone](https://www.capstone-engine.org)/[Keystone](https://www.keystone-engine.org)
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual](https://grammatech.github.io/gtirb/) describes the
 structure for common types of auxiliary data such as function boundary
 information, type information, or results of common analyses in
 [Standard AuxData Schemata](https://grammatech.github.io/gtirb/md__aux_data.html).
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 # Installing
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm](https://github.com/GrammaTech/ddisasm)
 disassembler and
 [gtirb-pprinter](https://github.com/GrammaTech/gtirb-pprinter) pretty
 printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  GTIRB is versioned with Major.Minor.Patch versioning
 where Major version increments will require significant source changes
 but should be very rare, Minor version increments may require small
 source changes, and Patch version increments shouldn&apos;t break any
 downstream builds.  We do not yet provide ABI compatibility across any
 version changes.
 .
 ## Python API
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/](https://grammatech.github.io/gtirb/pkgs/windows-debug/),
 and
 [windows-release/](https://grammatech.github.io/gtirb/pkgs/windows-release/).
 A symbol server for the debugging symbols for both the release and
 debug binaries is available at
 [https://download.grammatech.com/gtirb/files/](https://download.grammatech.com/gtirb/files/).
 For information about how to use a symbol server with your debugger,
 please see
 [docs.microsoft.com#Specify_symbol_locations_and_loading_behavior](https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior)
 or your debugger&apos;s documentation.
 .
 ## Ubuntu
 Packages for Ubuntu 16, 18, and 20 are available in the GTIRB apt
 repository.  The GTIRB package has some dependencies which are only
 available in other PPAs.  You will have to add these PPAs to your
 system in order to install the GTIRB package.
 .
 Instructions for adding the appropriate PPAS and installing GTIRB on each
 platform follow.
 .
 ### Ubuntu16
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb https://grammatech.github.io/gtirb/pkgs/xenial ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install --allow-unauthenticated libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu18
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu20
 ```sh
 sudo apt-get install software-properties-common
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/focal ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 Arch packages are available for download from
 [https://grammatech.github.io/gtirb/pkgs/arch/](https://grammatech.github.io/gtirb/pkgs/arch/)
 and may be directly installed with `pacman`.
 .
 Additionally, the Arch User Repository (AUR) https://aur.archlinux.org/ has packages
 for GTIRB (`gtirb-git`) the GTIRB Pretty Printer
 (`gtirb-pprinter-git`) and the datalog disassembler (`ddisasm-git`).
 Note that installing `ddisasm-git` will cause the other two packages
 to be installed as well given that they are both dependencies.
 .
 The following command will build and install GTIRB using the popular
 [aur helper](https://wiki.archlinux.org/index.php/AUR_helpers)
 [yay](https://github.com/Jguer/yay).
 ```sh
 yay gtirb-git
 ```
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake](https://cmake.org/), version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf](https://developers.google.com/protocol-buffers/), version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)](https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest), version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google&apos;s protocol;buffers](https://developers.google.com/protocol-buffers/) (i.e.,
 [protobuf](https://github.com/google/protobuf/wiki)), enabling
 [easy and efficient use from any programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf](https://github.com/google/protobuf/wiki)
 data produced by GTIRB allows for exploration and manipulation in the
 language of your choice. The [Google protocol;buffers](https://developers.google.com/protocol-buffers/) homepage
 lists the languages in which protocol buffers can be used directly;
 users of other languages can convert the protobuf-formatted data to
 JSON format and then use the JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.3-focal
Installed-Size: 24976

Package: libgtirb-dev-1.10.4
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.4 (=1.10.4-focal), libboost-dev (>=1.67) | libboost1.67-dev, libprotobuf-dev (>=3.6.1~), libprotobuf-dev (<<3.6.2)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dev-1.10.4/libgtirb-dev-1.10.4_1.10.4-focal_amd64.deb
Size: 4900516
SHA256: 8ab53998d4621fad69beff7ca51c5737325fee622c08782ab4fb29538600e68e
SHA1: 9ea116c554c8d92d596b74afd8e2ff34d9876ff9
MD5sum: 3ea63246aadb4b45ae25471466475d34
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.4-focal
Installed-Size: 24956

Package: libgtirb-dev-1.10.5
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.5 (=1.10.5-focal), libboost-dev (>=1.67) | libboost1.67-dev, libprotobuf-dev (>=3.6.1~), libprotobuf-dev (<<3.6.2)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dev-1.10.5/libgtirb-dev-1.10.5_1.10.5-focal_amd64.deb
Size: 4901380
SHA256: 9d2f1c83e3e9e8a7be1d78029d92d029b937551bd6595fee6d06e97ca08c0108
SHA1: 13c83f7b71fe2c95a5fbf9745f34fc15acd60e1a
MD5sum: e43f769a1a79e831e5671692f76b6366
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.5-focal
Installed-Size: 24960

Package: libgtirb-dev-1.10.6
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.6 (=1.10.6-focal), libboost-dev (>=1.67) | libboost1.67-dev, libprotobuf-dev (>=3.6.1~), libprotobuf-dev (<<3.6.2)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dev-1.10.6/libgtirb-dev-1.10.6_1.10.6-focal_amd64.deb
Size: 4901928
SHA256: 51f39830da9a7cd13b0ef809393d1b897244a1d0d7fb6beef0303e7d069d4c7a
SHA1: 1b7aab0b91b5d2cb3d29f3f444870e0a0c38d4e5
MD5sum: 952f89f15162974ce3e62a68d45c34cd
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.6-focal
Installed-Size: 24965

Package: libgtirb-dev-1.10.7
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.7 (=1.10.7-focal), libboost-dev (>=1.67) | libboost1.67-dev, libprotobuf-dev (>=3.6.1~), libprotobuf-dev (<<3.6.2)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-dev-1.10.7/libgtirb-dev-1.10.7_1.10.7-focal_amd64.deb
Size: 4903054
SHA256: 73ce7ee0589cb695b5ebfe593ec1623f32796868889a9c0d9e9870ccca73ad19
SHA1: 788249e94657e93011340dc874d7a9fd62c3ff47
MD5sum: 2c291363deb229c387a4948eb9f4f2f2
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt repository and may
 be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20
 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or
 `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost
 &gt; package from a PPA.  You can add it like this: `add-apt-repository
 ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 **Warning**:  There is a problem with the packages in the stable repository
 that will cause conflicts if you try `apt-get upgrade`.  In this case,
 uninstall and reinstall the packages you got from the GTIRB repository.  You
 may need to use `dpkg --remove` to remove the metapackages (e.g. `ddisasm`)
 before removing the concrete versioned packages (e.g. `ddisasm-1.5.1`).
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.7-focal
Installed-Size: 24967

Package: libgtirb-pprinter
Version: 1.8.3-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter/libgtirb-pprinter_1.8.3-focal_amd64.deb
Size: 2916
SHA256: 4ad0f4f5f2a76798a639a5c068bd7dc56b103cc26ed333fbe38914909e330520
SHA1: 54eb11f3cbd2e75969a9f319b13c2b6cda8ecd97
MD5sum: dcc00fc5a89c387a21f4c1f72d980a6e
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
  GTIRB Pretty Printer
  ====================
  .
  A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
  intermediate representation for binary analysis and reverse
  engineering to gas-syntax assembly code.
  .
  .
  ## Building
  .
  The pretty-printer uses C++17, and requires a compiler which supports
  that standard such as gcc 7, clang 6, or MSVC 2017.
  .
  To build and install the pretty printer, the following requirements
  should be installed:
  .
  * [GTIRB](https://github.com/grammatech/gtirb).
  * [Capstone](http://www.capstone-engine.org/). At the moment
    we require our own fork https://github.com/GrammaTech/capstone/tree/next
    that contains some additional fixes (until new official releases are cut).
  * [Boost](https://www.boost.org/), version 1.67.0 or later.
    * Requires the libraries:
      * filesystem
      * program_options
      * system
    * Ubuntu 18 and earlier provide out of date versions;
      build from source on those Ubuntu versions.
  .
  Note that these versions are newer than what your package manager may provide
  by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
  these dependencies from sources to avoid versioning problems.
  .
  Use the following options to configure cmake:
  - You can tell CMake which compiler to use with
    `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
  - Normally CMake will find GTIRB automatically, but if it does not you
    can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
  - gtirb-pprinter can make use of GTIRB in static library form (instead of
    shared library form, the default) if you use the flag
    `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
  - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
    statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
  - You can configure CMake to use a custom location for Capstone by specifying
    `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
  - You can use vcpkg on Windows to provide some dependencies by passing
    `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
  .
  Once the dependencies are installed, you can configure and build as follows:
  .
  ```sh
  cmake ./ -Bbuild
  cd build
  make
  ```
  .
  ## Installing
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
  .
  ## Usage
  .
  ### Generate reassembleable assembly code
  Pretty print the GTIRB for a simple hello world executable to an
  assembly file named `hello.S`, assemble this file with the GNU
  assembler to an object file named `hello.o`, and link this object file
  into an executable.
  .
  ```sh
  gtirb-pprinter hello.gtirb --asm hello.S
  as hello.S -o hello.o
  ld hello.o -o hello
  ./hello
  ```
  ### Generate a new binary
  The `--binary` flag to gtirb-pprinter generates a new binary by
  calling `gcc` directly.
  .
  ```sh
  gtirb-pprinter hello.gtirb --binary hello
  ```
  .
  This option admits an argument `--library-paths` or `-L` to
  specify additional paths where libraries might be located.
  .
  For example:
  ```sh
  gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
  ```
  .
  ## AuxData Used by the Pretty Printer
  .
  Generating assembly depends on a number of additional pieces of information
  beyond the symbols and instruction/data bytes in the IR. The pretty printer
  expects this information to be available in a number of
  [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
  objects stored with the IR. We document the expected keys along with the
  associated types and contents in this table.
  .
  | Key              | Type                                           | Purpose                                                                                                                              |
  |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
  | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
  | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
  | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
  | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
  | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
  | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
  | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
  .
  ## AuxData Used by the Binary Printer
  .
  In order to generate new binaries, gtirb-binary-printer also uses the following tables:
  .
  | Key              | Type                             | Purpose                                                                          |
  |------------------|----------------------------------|----------------------------------------------------------------------------------|
  | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
  | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
  .
Depends: libgtirb-pprinter-1.8.3 (= 1.8.3-focal)

Package: libgtirb-pprinter-1.6.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.3 (>= 1.10.3-focal), libgtirb-1.10.3 (<< 2.0.0), libboost-filesystem1.71.0, libcapstone-dev-4.0.1-gt3 (= 1:4.0.1-gt3)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-1.6.0/libgtirb-pprinter-1.6.0_1.6.0-focal_amd64.deb
Size: 230596
SHA256: 998d3067acf1663d8350a5a36146354cf0ee60eedf600979bd9bb5f8e24cceb1
SHA1: 328389f7f0dd869aa259a498a7938659b2cb0d1b
MD5sum: 7a0eaf2414f2ea8cc5f96b11619dee59
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0-focal or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.6.0-focal
Installed-Size: 2916

Package: libgtirb-pprinter-1.7.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.4 (=1.10.4-focal), libboost-filesystem1.71.0, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-1.7.0/libgtirb-pprinter-1.7.0_1.7.0-focal_amd64.deb
Size: 363000
SHA256: baa0f37fdb84625916d5f79b31d18a7d5d0fd7179654e3b27f69e7e8e9cc0bb5
SHA1: d5da218cf282385e7ef500779b0d643e53df5458
MD5sum: 5fde3e92ceed8a0dfc9419bcdf1c4afb
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.7.0-focal
Installed-Size: 3353

Package: libgtirb-pprinter-1.8.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-1.10.5 (=1.10.5-focal), libboost-filesystem1.71.0, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-1.8.0/libgtirb-pprinter-1.8.0_1.8.0-focal_amd64.deb
Size: 405554
SHA256: feaa568035d594c864f3c0e741b9391bc322d88e5af67a90fa6c499cca8cec31
SHA1: 7622f9476c00ae2dc235825f8675cffaa7b252d7
MD5sum: 27c7cba1e539434a58003daf96f217ba
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.0-focal
Installed-Size: 3747

Package: libgtirb-pprinter-1.8.2
Architecture: amd64
Depends: gcc, libstdc++6, libc6, libgcc1, libgtirb-1.10.6 (=1.10.6-focal), libboost-filesystem1.71.0, libcapstone-dev-4.0.2-gt1 (=1:4.0.2-gt1)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-1.8.2/libgtirb-pprinter-1.8.2_1.8.2-focal_amd64.deb
Size: 417548
SHA256: a452ea6e85bbe41c3e19d46fe2428c2fe7946dc8de5fa67a7e6a58ee2a2d80d0
SHA1: 98778ad5fcc33c8d30b45295a14c12a75cfac880
MD5sum: cec813e71b06116b57daf986d6849587
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.2-focal
Installed-Size: 3845

Package: libgtirb-pprinter-1.8.3
Architecture: amd64
Depends: gcc, libstdc++6, libc6, libgcc1, libgtirb-1.10.7 (=1.10.7-focal), libboost-filesystem1.71.0, libcapstone-dev-5.0.0-gt2 (=1:5.0.0-gt2)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-1.8.3/libgtirb-pprinter-1.8.3_1.8.3-focal_amd64.deb
Size: 443120
SHA256: f61c0b2dbb04ee2bcb33e909bae68af3ddecaff2911c4d662ce8dcbda928f2ab
SHA1: ecd4c7c3ab6a877a3c21bac21f9c791ae84d3885
MD5sum: 25cb4a29b20682c0eace122312c49e1c
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.3-focal
Installed-Size: 4064

Package: libgtirb-pprinter-dbg
Version: 1.8.3-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dbg/libgtirb-pprinter-dbg_1.8.3-focal_amd64.deb
Size: 2920
SHA256: 0e9084d6ea331982cb86c3a05a948c95e0a2c9bd0b428a63994bc777c7b57fc5
SHA1: ad9ea58efc6c2e90cadfd78124fa711b083be372
MD5sum: 2b772b77162282883ecdb25d1ba27d12
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
  GTIRB Pretty Printer
  ====================
  .
  A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
  intermediate representation for binary analysis and reverse
  engineering to gas-syntax assembly code.
  .
  .
  ## Building
  .
  The pretty-printer uses C++17, and requires a compiler which supports
  that standard such as gcc 7, clang 6, or MSVC 2017.
  .
  To build and install the pretty printer, the following requirements
  should be installed:
  .
  * [GTIRB](https://github.com/grammatech/gtirb).
  * [Capstone](http://www.capstone-engine.org/). At the moment
    we require our own fork https://github.com/GrammaTech/capstone/tree/next
    that contains some additional fixes (until new official releases are cut).
  * [Boost](https://www.boost.org/), version 1.67.0 or later.
    * Requires the libraries:
      * filesystem
      * program_options
      * system
    * Ubuntu 18 and earlier provide out of date versions;
      build from source on those Ubuntu versions.
  .
  Note that these versions are newer than what your package manager may provide
  by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
  these dependencies from sources to avoid versioning problems.
  .
  Use the following options to configure cmake:
  - You can tell CMake which compiler to use with
    `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
  - Normally CMake will find GTIRB automatically, but if it does not you
    can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
  - gtirb-pprinter can make use of GTIRB in static library form (instead of
    shared library form, the default) if you use the flag
    `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
  - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
    statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
  - You can configure CMake to use a custom location for Capstone by specifying
    `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
  - You can use vcpkg on Windows to provide some dependencies by passing
    `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
  .
  Once the dependencies are installed, you can configure and build as follows:
  .
  ```sh
  cmake ./ -Bbuild
  cd build
  make
  ```
  .
  ## Installing
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
  .
  ## Usage
  .
  ### Generate reassembleable assembly code
  Pretty print the GTIRB for a simple hello world executable to an
  assembly file named `hello.S`, assemble this file with the GNU
  assembler to an object file named `hello.o`, and link this object file
  into an executable.
  .
  ```sh
  gtirb-pprinter hello.gtirb --asm hello.S
  as hello.S -o hello.o
  ld hello.o -o hello
  ./hello
  ```
  ### Generate a new binary
  The `--binary` flag to gtirb-pprinter generates a new binary by
  calling `gcc` directly.
  .
  ```sh
  gtirb-pprinter hello.gtirb --binary hello
  ```
  .
  This option admits an argument `--library-paths` or `-L` to
  specify additional paths where libraries might be located.
  .
  For example:
  ```sh
  gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
  ```
  .
  ## AuxData Used by the Pretty Printer
  .
  Generating assembly depends on a number of additional pieces of information
  beyond the symbols and instruction/data bytes in the IR. The pretty printer
  expects this information to be available in a number of
  [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
  objects stored with the IR. We document the expected keys along with the
  associated types and contents in this table.
  .
  | Key              | Type                                           | Purpose                                                                                                                              |
  |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
  | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
  | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
  | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
  | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
  | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
  | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
  | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
  .
  ## AuxData Used by the Binary Printer
  .
  In order to generate new binaries, gtirb-binary-printer also uses the following tables:
  .
  | Key              | Type                             | Purpose                                                                          |
  |------------------|----------------------------------|----------------------------------------------------------------------------------|
  | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
  | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
  .
Depends: libgtirb-pprinter-dbg-1.8.3 (= 1.8.3-focal)

Package: libgtirb-pprinter-dbg-1.6.0
Architecture: amd64
Depends: libgtirb-pprinter-1.6.0 (= 1.6.0-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dbg-1.6.0/libgtirb-pprinter-dbg-1.6.0_1.6.0-focal_amd64.deb
Size: 7941372
SHA256: 2019ba2498fbf0d025485b749ef5f60f83f315722e27f9ea8c73818718f69903
SHA1: 2a9a6a3916990f0da3a42c4a930c289ddce6bf63
MD5sum: 7e8b1f37169b80b120e26b235853170b
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0-focal or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.6.0-focal
Installed-Size: 51956

Package: libgtirb-pprinter-dbg-1.7.0
Architecture: amd64
Depends: libgtirb-pprinter-1.7.0 (=1.7.0-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dbg-1.7.0/libgtirb-pprinter-dbg-1.7.0_1.7.0-focal_amd64.deb
Size: 15007654
SHA256: f8673bf465ff19d8284cbd7909ab87e60cd58292ebbebf9e14669322f24757a0
SHA1: 785d3b03ac20f454eb0c16158e8512b77b93a061
MD5sum: 96a86f5fb32255eef0d1cbc87a290a9f
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.7.0-focal
Installed-Size: 58853

Package: libgtirb-pprinter-dbg-1.8.0
Architecture: amd64
Depends: libgtirb-pprinter-1.8.0 (=1.8.0-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dbg-1.8.0/libgtirb-pprinter-dbg-1.8.0_1.8.0-focal_amd64.deb
Size: 16519370
SHA256: 940ff643bc388ad2c1ec081a1419a6e236d5fcdf7d458b49dc0f14b22d64146b
SHA1: 303ad65325a96fb06cf85a47b4f2bd57339bdd9c
MD5sum: c9a67b94443a781ea2c1f15f64de5cc4
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.0-focal
Installed-Size: 64191

Package: libgtirb-pprinter-dbg-1.8.2
Architecture: amd64
Depends: libgtirb-pprinter-1.8.2 (=1.8.2-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dbg-1.8.2/libgtirb-pprinter-dbg-1.8.2_1.8.2-focal_amd64.deb
Size: 16769930
SHA256: be84fa14c9d2cc992609733fd8c6838cb392f440402668fc84bfac4fbf1fb662
SHA1: 4ea0de4e44e2cdafc023d2b1fe69856d499c2e15
MD5sum: b84f43725e08bbeb50ec6d06cca9a2e3
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.2-focal
Installed-Size: 65180

Package: libgtirb-pprinter-dbg-1.8.3
Architecture: amd64
Depends: libgtirb-pprinter-1.8.3 (=1.8.3-focal)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dbg-1.8.3/libgtirb-pprinter-dbg-1.8.3_1.8.3-focal_amd64.deb
Size: 17824890
SHA256: 8fcec04a247c1c83c037afbae038e3fdc602a5e72f21bf5c715a1fb9fdf8f0cc
SHA1: 48f57c9225accde99513cf772e06b68ee76a4bbf
MD5sum: 7e1f2388cadee95a330213033d55ee27
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.3-focal
Installed-Size: 68557

Package: libgtirb-pprinter-dev
Version: 1.8.3-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dev/libgtirb-pprinter-dev_1.8.3-focal_amd64.deb
Size: 2920
SHA256: a4ff3533ea3acea97e649565c3263f2aa0335db857d917f82fcb8bb29380e3bd
SHA1: 6591f2ddbb47e397e74a1d6549755250a6370bab
MD5sum: fae79c78a0e4ff3fdc1d0a5c0dcb6d57
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
  GTIRB Pretty Printer
  ====================
  .
  A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
  intermediate representation for binary analysis and reverse
  engineering to gas-syntax assembly code.
  .
  .
  ## Building
  .
  The pretty-printer uses C++17, and requires a compiler which supports
  that standard such as gcc 7, clang 6, or MSVC 2017.
  .
  To build and install the pretty printer, the following requirements
  should be installed:
  .
  * [GTIRB](https://github.com/grammatech/gtirb).
  * [Capstone](http://www.capstone-engine.org/). At the moment
    we require our own fork https://github.com/GrammaTech/capstone/tree/next
    that contains some additional fixes (until new official releases are cut).
  * [Boost](https://www.boost.org/), version 1.67.0 or later.
    * Requires the libraries:
      * filesystem
      * program_options
      * system
    * Ubuntu 18 and earlier provide out of date versions;
      build from source on those Ubuntu versions.
  .
  Note that these versions are newer than what your package manager may provide
  by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
  these dependencies from sources to avoid versioning problems.
  .
  Use the following options to configure cmake:
  - You can tell CMake which compiler to use with
    `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
  - Normally CMake will find GTIRB automatically, but if it does not you
    can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
  - gtirb-pprinter can make use of GTIRB in static library form (instead of
    shared library form, the default) if you use the flag
    `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
  - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
    statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
  - You can configure CMake to use a custom location for Capstone by specifying
    `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
  - You can use vcpkg on Windows to provide some dependencies by passing
    `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
  .
  Once the dependencies are installed, you can configure and build as follows:
  .
  ```sh
  cmake ./ -Bbuild
  cd build
  make
  ```
  .
  ## Installing
  See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
  .
  ## Usage
  .
  ### Generate reassembleable assembly code
  Pretty print the GTIRB for a simple hello world executable to an
  assembly file named `hello.S`, assemble this file with the GNU
  assembler to an object file named `hello.o`, and link this object file
  into an executable.
  .
  ```sh
  gtirb-pprinter hello.gtirb --asm hello.S
  as hello.S -o hello.o
  ld hello.o -o hello
  ./hello
  ```
  ### Generate a new binary
  The `--binary` flag to gtirb-pprinter generates a new binary by
  calling `gcc` directly.
  .
  ```sh
  gtirb-pprinter hello.gtirb --binary hello
  ```
  .
  This option admits an argument `--library-paths` or `-L` to
  specify additional paths where libraries might be located.
  .
  For example:
  ```sh
  gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
  ```
  .
  ## AuxData Used by the Pretty Printer
  .
  Generating assembly depends on a number of additional pieces of information
  beyond the symbols and instruction/data bytes in the IR. The pretty printer
  expects this information to be available in a number of
  [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
  objects stored with the IR. We document the expected keys along with the
  associated types and contents in this table.
  .
  | Key              | Type                                           | Purpose                                                                                                                              |
  |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
  | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
  | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
  | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
  | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
  | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
  | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
  | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
  .
  ## AuxData Used by the Binary Printer
  .
  In order to generate new binaries, gtirb-binary-printer also uses the following tables:
  .
  | Key              | Type                             | Purpose                                                                          |
  |------------------|----------------------------------|----------------------------------------------------------------------------------|
  | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
  | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
  .
Depends: libgtirb-pprinter-dev-1.8.3 (= 1.8.3-focal)

Package: libgtirb-pprinter-dev-1.6.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-dev-1.10.3 (>= 1.10.3-focal), libgtirb-dev-1.10.3 (<< 2.0.0), libgtirb-pprinter-1.6.0 (= 1.6.0-focal), libboost-dev, libcapstone-dev-4.0.1-gt3 (= 1:4.0.1-gt3)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dev-1.6.0/libgtirb-pprinter-dev-1.6.0_1.6.0-focal_amd64.deb
Size: 16208
SHA256: 3e99d88d3972e267a2948441625d8a7ca2de3093d2d2a862588abe17ea58d54c
SHA1: 0ac9f5d634c3a11394501689f17cd9ab3df9cfdc
MD5sum: 7b21a9e0e3a1d8f274c2c76775c64077
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0-focal or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.6.0-focal
Installed-Size: 97

Package: libgtirb-pprinter-dev-1.7.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-dev-1.10.4 (=1.10.4-focal), libgtirb-pprinter-1.7.0 (=1.7.0-focal), libboost-dev, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dev-1.7.0/libgtirb-pprinter-dev-1.7.0_1.7.0-focal_amd64.deb
Size: 18664
SHA256: 1a1e0b77c1d07e0c128a31913ac26cb9f1834cca35a461745546bfbaae2f0bc7
SHA1: 13218996d1d836ef8dc80768522ee773e7a5f7e4
MD5sum: b6c2f3df40236372189ed5a011e1b416
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.7.0-focal
Installed-Size: 104

Package: libgtirb-pprinter-dev-1.8.0
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-dev-1.10.5 (=1.10.5-focal), libgtirb-pprinter-1.8.0 (=1.8.0-focal), libboost-dev, libcapstone-dev-4.0.2-gt0 (=1:4.0.2-gt0)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dev-1.8.0/libgtirb-pprinter-dev-1.8.0_1.8.0-focal_amd64.deb
Size: 19418
SHA256: b808842a9bc4f06fb2a798545dfc94f4d55c674e9b11e41081d1bd08bd2c7c5d
SHA1: f2d319246ff0b79acead54e65e8b01915ca41633
MD5sum: b1ae6965e80c5b71fb05605302925928
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.0-focal
Installed-Size: 109

Package: libgtirb-pprinter-dev-1.8.2
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-dev-1.10.6 (=1.10.6-focal), libgtirb-pprinter-1.8.2 (=1.8.2-focal), libboost-dev, libcapstone-dev-4.0.2-gt1 (=1:4.0.2-gt1)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dev-1.8.2/libgtirb-pprinter-dev-1.8.2_1.8.2-focal_amd64.deb
Size: 19870
SHA256: 49a2ff1bdce50d9527e9ff68d9bd9c18c857f6993afda8e5c7dbdb3d6df6a41d
SHA1: c3860c3f645df0e2d8a7e2d60e5dad7f97e3ac01
MD5sum: 4f4e28e52572d5e3102a62f34bffe789
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | elfSectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the ELF section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.2-focal
Installed-Size: 111

Package: libgtirb-pprinter-dev-1.8.3
Architecture: amd64
Depends: libstdc++6, libc6, libgcc1, libgtirb-dev-1.10.7 (=1.10.7-focal), libgtirb-pprinter-1.8.3 (=1.8.3-focal), libboost-dev, libcapstone-dev-5.0.0-gt2 (=1:5.0.0-gt2)
Priority: optional
Section: devel
Filename: pool/stable/libg/libgtirb-pprinter-dev-1.8.3/libgtirb-pprinter-dev-1.8.3_1.8.3-focal_amd64.deb
Size: 22174
SHA256: a66bba783a679d74850db685ec19906a29b77f375dbe3a3e9968af6b2b9fcf83
SHA1: 4580ffd55939c4c0c8e8076496402687b4db640a
MD5sum: ffc2d8824edbe076f651079e82e75b10
Description: A pretty printer from the GTIRB intermediate representation for binary analysis and reverse engineering to gas-syntax assembly code.
 GTIRB Pretty Printer
 ====================
 .
 A pretty printer from the [GTIRB](https://github.com/grammatech/gtirb)
 intermediate representation for binary analysis and reverse
 engineering to gas-syntax assembly code.
 .
 .
 ## Building
 .
 The pretty-printer uses C++17, and requires a compiler which supports
 that standard such as gcc 7, clang 6, or MSVC 2017.
 .
 To build and install the pretty printer, the following requirements
 should be installed:
 .
 * [GTIRB](https://github.com/grammatech/gtirb).
 * [Capstone](http://www.capstone-engine.org/). At the moment
   we require our own fork https://github.com/GrammaTech/capstone/tree/next
   that contains some additional fixes (until new official releases are cut).
 * [Boost](https://www.boost.org/), version 1.67.0 or later.
   * Requires the libraries:
     * filesystem
     * program_options
     * system
   * Ubuntu 18 and earlier provide out of date versions;
     build from source on those Ubuntu versions.
 .
 Note that these versions are newer than what your package manager may provide
 by default: This is true on Ubuntu 18, Debian 10, and others. Prefer building
 these dependencies from sources to avoid versioning problems.
 .
 Use the following options to configure cmake:
 - You can tell CMake which compiler to use with
   `-DCMAKE_CXX_COMPILER=&lt;compiler&gt;`.
 - Normally CMake will find GTIRB automatically, but if it does not you
   can pass `-Dgtirb_DIR=&lt;path-to-gtirb-build&gt;`.
 - gtirb-pprinter can make use of GTIRB in static library form (instead of
   shared library form, the default) if you use the flag
   `-DGTIRB_PPRINTER_BUILD_SHARED_LIBS=OFF`.
 - Furthermore, if you want to produce a `gtirb-pprinter` executable that links
   statically, specify `-DGTIRB_PPRINTER_STATIC_DRIVERS=ON`.
 - You can configure CMake to use a custom location for Capstone by specifying
   `-DCMAKE_LIBRARY_PATH=&lt;path-to-capstone&gt;`.
 - You can use vcpkg on Windows to provide some dependencies by passing
   `-DCMAKE_TOOLCHAIN_FILE=&lt;path-to-vcpkg\scripts\buildsystems\vcpkg.cmake&gt;`.
 .
 Once the dependencies are installed, you can configure and build as follows:
 .
 ```sh
 cmake ./ -Bbuild
 cd build
 make
 ```
 .
 ## Installing
 See the [GTIRB readme](https://github.com/GrammaTech/gtirb/#installing).
 .
 ## Usage
 .
 ### Generate reassembleable assembly code
 Pretty print the GTIRB for a simple hello world executable to an
 assembly file named `hello.S`, assemble this file with the GNU
 assembler to an object file named `hello.o`, and link this object file
 into an executable.
 .
 ```sh
 gtirb-pprinter hello.gtirb --asm hello.S
 as hello.S -o hello.o
 ld hello.o -o hello
 ./hello
 ```
 ### Generate a new binary
 The `--binary` flag to gtirb-pprinter generates a new binary by
 calling `gcc` directly.
 .
 ```sh
 gtirb-pprinter hello.gtirb --binary hello
 ```
 .
 This option admits an argument `--library-paths` or `-L` to
 specify additional paths where libraries might be located.
 .
 For example:
 ```sh
 gtirb-pprinter hello.gtirb --binary hello -L . -L /usr/local/lib
 ```
 .
 ## AuxData Used by the Pretty Printer
 .
 Generating assembly depends on a number of additional pieces of information
 beyond the symbols and instruction/data bytes in the IR. The pretty printer
 expects this information to be available in a number of
 [AuxData](https://github.com/GrammaTech/gtirb/blob/master/README.md#auxiliary-data)
 objects stored with the IR. We document the expected keys along with the
 associated types and contents in this table.
 .
 | Key              | Type                                           | Purpose                                                                                                                              |
 |------------------|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
 | comments         | `std::map&lt;gtirb::Offset, std::string&gt;`           | Per-instruction or data element comments.                                                                                          |
 | functionEntries    | `std::map&lt;gtirb::UUID, std::set&lt;gtirb::UUID&gt;&gt;` | UUIDs of the blocks that are entry points of functions.                                                                                              |
 | symbolForwarding | `std::map&lt;gtirb::UUID, gtirb::UUID&gt;`           | Map from symbols to other symbols. This table is used to forward symbols due to relocations or due to the use of plt and got tables. |
 | encodings            | `std::map&lt;gtirb::UUID,std::string&gt;`            | Map from (typed) data objects to the encoding of the data,  expressed as a std::string containing an assembler encoding specifier: &quot;string&quot;, &quot;uleb128&quot; or &quot;sleb128&quot;.     |
 | sectionProperties | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, uint64_t&gt;&gt;` | Map from section UUIDs to tuples with the section types and flags. |
 | cfiDirectives   | `std::map&lt;gtirb::Offset, std::vector&lt;std::tuple&lt;std::string, std::vector&lt;int64_t&gt;, gtirb::UUID&gt;&gt;&gt;` | Map from Offsets to  vector of cfi directives. A cfi directive contains: a string describing the directive, a vector  of numeric arguments, and an optional symbolic argument (represented with the UUID of the symbol). |
 | elfSymbolInfo | `std::map&lt;gtirb::UUID, std::tuple&lt;uint64_t, std::string, std::string, std::string, uint64_t&gt;&gt;` | On ELF targets only: Map from symbols to their type, binding, and visibility categories. |
 .
 ## AuxData Used by the Binary Printer
 .
 In order to generate new binaries, gtirb-binary-printer also uses the following tables:
 .
 | Key              | Type                             | Purpose                                                                          |
 |------------------|----------------------------------|----------------------------------------------------------------------------------|
 | libraries        | `std::vector&lt;std::string&gt;`       | Names of the libraries that are needed.                                          |
 | libraryPaths     | `std::vector&lt;std::string&gt;`       | Paths contained in the rpath of the binary                                       |
 .
Maintainer: gtirb@grammatech.com
Version: 1.8.3-focal
Installed-Size: 121

Package: python3-gtirb
Version: 1.10.5-focal
Architecture: amd64
Maintainer: gtirb@grammatech.com
Priority: optional
Section: devel
Filename: pool/stable/p/python3-gtirb/python3-gtirb_1.10.5-focal_amd64.deb
Size: 4972
SHA256: 8fb830a2d042c97716fc5640d9407eab9cb8e4aa18139de6169e2cba3e6b5e5d
SHA1: f364adeb8247f69ebdd3856571ac0f78d9f1e6ae
MD5sum: 3a67cc66780525be18e7ec893093b426
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
  # GTIRB
  .
  The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
  machine code analysis and rewriting data structure.  It is intended to
  facilitate the communication of binary IR between programs performing
  binary disassembly, analysis, transformation, and pretty printing.
  GTIRB is modeled on LLVM-IR, and seeks to serve a similar
  functionality of encouraging communication and interoperability
  between tools.
  .
  The remainder of this file describes various aspects of GTIRB:
  - [Structure](#structure)
  - [Installing](#installing)
  - [Building](#building)
  - [Usage](#usage)
  .
  # Structure
  .
  GTIRB has the following structure.  Solid lines denote inheritance.
  Dotted lines denote reference by UUID.
  .
  ![GTIRB Data Structure](.gtirb.svg)
  .
  ## IR
  .
  An instance of GTIRB may include multiple modules (`Module`) which
  represent loadable objects such as executables or libraries, an
  inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
  (`AuxData`) which can hold arbitrary analysis results in user-defined
  formats which can easily reference other elements of the IR.  Each
  module holds information such as symbols (`Symbol`) and sections which
  themselves hold the actual bytes and data and code blocks of the
  module.  The CFG consists of basic blocks (`Block`) and control flow
  edges between these blocks.  Each data or code block references a
  range of bytes in a byte interval (`ByteInterval`).  A section may
  hold one large byte interval holding all blocks---if the relative
  positions of blocks in that section are defined---or may hold one byte
  interval per block---if the relative positions of blocks is not
  defined, e.g. for the code blocks in the `.text` section during
  program rewriting.  Each symbol holds a pointer to the block or datum
  it references.
  .
  .
  ## Instructions
  .
  GTIRB explicitly does NOT represent instructions or instruction
  semantics but does provide symbolic operand information and access to
  the bytes.  There are many *intermediate languages* (IL)s for
  representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
  [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
  or any other IL by storing instructions generally and efficiently as
  *raw machine-code bytes* and separately storing the symbolic and
  control flow information.  The popular [Capstone][]/[Keystone][]
  decoder/encoder provide an excellent option to read and write
  instructions from/to GTIRB&apos;s machine-code byte representation without
  committing to any particular semantic IL.  By supporting multiple ILs
  and separate storage of analysis results in auxiliary data tables
  GTIRB enables collaboration between independent binary analysis and
  rewriting teams and tools.
  .
  [BAP]: https://github.com/BinaryAnalysisPlatform/bap
  [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
  [Angr]: http://angr.io
  [Vex]: https://github.com/angr/pyvex
  [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
  [Capstone]: https://www.capstone-engine.org
  [Keystone]: https://www.keystone-engine.org
  .
  .
  ## Auxiliary Data
  .
  GTIRB provides for the sharing of additional information,
  e.g. analysis results, in the form of `AuxData` objects.  These can
  store maps and vectors of basic GTIRB types in a portable way. The
  [GTIRB manual][] describes the structure for common types of auxiliary
  data such as function boundary information, type information, or
  results of common analyses in [Standard AuxData Schemata][].
  .
  [GTIRB manual]: https://grammatech.github.io/gtirb/
  [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
  .
  .
  ## UUIDs
  .
  Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
  and blocks (`Block`)---has a universally unique identifier (UUID).
  UUIDs allow both first-class IR components and AuxData tables to
  reference elements of the IR.
  .
  Instructions and symbolic operands can be addressed by the class
  `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
  block) and an offset.
  .
  .
  # Installing
  .
  Packages currently existing for easily installing GTIRB (and attendant
  tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
  pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
  instructions.  Additionally, a public Docker image exists at
  [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
  versioned with Major.Minor.Patch versioning where Major version
  increments will require significant source changes but should be very
  rare, Minor version increments may require small source changes, and
  Patch version increments shouldn&apos;t break any downstream builds.  We do
  not yet provide ABI compatibility across any version changes.
  .
  [ddisasm]: https://github.com/GrammaTech/ddisasm
  [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
  [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
  .
  .
  ## Python API
  .
  The GTIRB Python API may be installed with the following.  Note
  however, that installation of the `ddisasm` and `gtirb-pprinter`
  packages as described below is recommended for use with every API.
  ```sh
  pip install gtirb
  ```
  .
  ## Windows
  .
  Pre-built debug and release binaries are available for Windows at:
  [windows-debug/][], and [windows-release/][].  A symbol server for the
  debugging symbols for both the release and debug binaries is available
  at [https://download.grammatech.com/gtirb/files/symbol-server/][].
  For information about how to use a symbol server with your debugger,
  please see [Specify_symbol_locations_and_loading_behavior][] or your
  debugger&apos;s documentation.
  .
  [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
  [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
  [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
  [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
  .
  .
  ## Ubuntu
  .
  Packages for Ubuntu 18 and 20 are available in the GTIRB apt
  repository and may be installed per the following instructions.
  .
  First, add GrammaTech&apos;s APT key.
  ```sh
  wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
  ```
  .
  Next update your sources.list file.
  ```sh
  echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
  ```
  Where:
  - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
  - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
  .
  &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
  .
  Finally update your package database and install the core GTIRB tools:
  ```sh
  sudo apt-get update
  sudo apt-get install libgtirb gtirb-pprinter ddisasm
  ```
  .
  ## Arch Linux
  .
  The Arch User Repository ([AUR][]) includes packages for GTIRB:
  `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
  command will build and install all three packages using the popular
  [aur helper][] [yay][].
  ```sh
  yay ddisasm-git
  ```
  .
  [AUR]: https://aur.archlinux.org/
  [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
  [yay]: https://github.com/Jguer/yay
  .
  .
  # Building
  .
  GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
  and Visual Studio compilers supporting at least C++17.  GTIRB uses
  CMake which must be installed with at least version 3.10.
  .
  The common build process looks like this:
  ```sh
  mkdir build
  cd build
  # Note: You may wish to add some -D arguments to the next command. See below.
  cmake &lt;path/to/gtirb&gt;
  cmake --build .
  # Run the test suite.
  ctest
  ```
  .
  For customizing the GTIRB build, you can get a list of customization options by
  navigating to your build directory and running:
  .
  ```sh
  cmake -LH
  ```
  .
  ## Requirements
  .
  To build and install GTIRB, the following requirements should be installed:
  .
  - [CMake][], version 3.10.0 or higher.
     - Ubuntu 18 provides this version via the APT package `cmake`.
     - Ubuntu 16 and earlier provide out of date versions; build from
       source on those versions.
  - [Protobuf][], version
    3.0.0 or later.
    - Ubuntu 18 provides this version via the APT packages
      `libprotobuf-dev` and `protobuf-compiler`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
  - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
    - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
  .
  [CMake]: https://cmake.org/
  [Protobuf]: https://developers.google.com/protocol-buffers/
  [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
  .
  .
  # Usage
  .
  GTIRB is designed to be serialized using [Google protocol buffers][]
  (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
  .
  GTIRB may also be used through a dedicated API implemented in multiple
  languages. The APIs provide efficient data structures suitable for use
  by binary analysis and rewriting applications; see
  [below](#gtirb-api-implementations) for details.
  .
  [Google protocol buffers]: https://developers.google.com/protocol-buffers/
  [protobuf]: https://github.com/google/protobuf/wiki
  .
  .
  ## Using Serialized GTIRB Data
  .
  The serialized [protobuf][] data produced by GTIRB allows for
  exploration and manipulation in the language of your choice. The
  [Google protocol buffers][] homepage lists the languages in which
  protocol buffers can be used directly; users of other languages can
  convert the protobuf-formatted data to JSON format and then use the
  JSON data in their applications.
  .
  The `proto` directory in this repository contains the protocol buffer
  message type definitions for GTIRB. You can inspect these `.proto`
  files to determine the structure of the various GTIRB message
  types. The top-level message type is `IR`.
  .
  For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
  .
  .
  ## GTIRB API Implementations
  .
  The GTIRB API is currently available in C++, Python, and Common Lisp.
  There is a *partial* Java API which is not ready for external use.
  For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
  different API implementations, see:
  .
    - [C++ API](doc/cpp/README.md)
    - [Python API](python/README.md)
    - [Common Lisp API](cl/README.md)
    - Java API **incomplete**
  .
Depends: python3-gtirb-1.10.5 (= 1.10.5-focal)

Package: python3-gtirb-1.10.3
Architecture: amd64
Depends: python3, python3-protobuf, python3-networkx
Priority: optional
Section: devel
Filename: pool/stable/p/python3-gtirb-1.10.3/python3-gtirb-1.10.3_1.10.3-focal_amd64.deb
Size: 69620
SHA256: fabdcfa3442e65a9b726b82c95ac6226bdbd6864c5fb130492706144bc03ff71
SHA1: 8fd79f8cee3f6f92c44f296225729e9c9a0dc17e
MD5sum: e6f0194b54e17fcce32c6d9a0edf7663
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g.,
 [BAP](https://github.com/BinaryAnalysisPlatform/bap)&apos;s
 [BIL](https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf),
 [Angr](http://angr.io)&apos;s [Vex](https://github.com/angr/pyvex), or
 [Ghidra](https://www.nsa.gov/resources/everyone/ghidra/)&apos;s P-code).
 GTIRB works with these or any other IL by storing instructions
 generally and efficiently as *raw machine-code bytes* and separately
 storing the symbolic and control flow information.  The popular
 [Capstone](https://www.capstone-engine.org)/[Keystone](https://www.keystone-engine.org)
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual](https://grammatech.github.io/gtirb/) describes the
 structure for common types of auxiliary data such as function boundary
 information, type information, or results of common analyses in
 [Standard AuxData Schemata](https://grammatech.github.io/gtirb/md__aux_data.html).
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 # Installing
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm](https://github.com/GrammaTech/ddisasm)
 disassembler and
 [gtirb-pprinter](https://github.com/GrammaTech/gtirb-pprinter) pretty
 printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  GTIRB is versioned with Major.Minor.Patch versioning
 where Major version increments will require significant source changes
 but should be very rare, Minor version increments may require small
 source changes, and Patch version increments shouldn&apos;t break any
 downstream builds.  We do not yet provide ABI compatibility across any
 version changes.
 .
 ## Python API
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/](https://grammatech.github.io/gtirb/pkgs/windows-debug/),
 and
 [windows-release/](https://grammatech.github.io/gtirb/pkgs/windows-release/).
 A symbol server for the debugging symbols for both the release and
 debug binaries is available at
 [https://download.grammatech.com/gtirb/files/](https://download.grammatech.com/gtirb/files/).
 For information about how to use a symbol server with your debugger,
 please see
 [docs.microsoft.com#Specify_symbol_locations_and_loading_behavior](https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior)
 or your debugger&apos;s documentation.
 .
 ## Ubuntu
 Packages for Ubuntu 16, 18, and 20 are available in the GTIRB apt
 repository.  The GTIRB package has some dependencies which are only
 available in other PPAs.  You will have to add these PPAs to your
 system in order to install the GTIRB package.
 .
 Instructions for adding the appropriate PPAS and installing GTIRB on each
 platform follow.
 .
 ### Ubuntu16
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:maarten-fonville/protobuf
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb https://grammatech.github.io/gtirb/pkgs/xenial ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install --allow-unauthenticated libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu18
 ```sh
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:mhier/libboost-latest
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/bionic ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ### Ubuntu20
 ```sh
 sudo apt-get install software-properties-common
 echo &quot;deb [trusted=yes] https://grammatech.github.io/gtirb/pkgs/focal ./&quot; | sudo tee -a /etc/apt/sources.list.d/gtirb.list
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 Arch packages are available for download from
 [https://grammatech.github.io/gtirb/pkgs/arch/](https://grammatech.github.io/gtirb/pkgs/arch/)
 and may be directly installed with `pacman`.
 .
 Additionally, the Arch User Repository (AUR) https://aur.archlinux.org/ has packages
 for GTIRB (`gtirb-git`) the GTIRB Pretty Printer
 (`gtirb-pprinter-git`) and the datalog disassembler (`ddisasm-git`).
 Note that installing `ddisasm-git` will cause the other two packages
 to be installed as well given that they are both dependencies.
 .
 The following command will build and install GTIRB using the popular
 [aur helper](https://wiki.archlinux.org/index.php/AUR_helpers)
 [yay](https://github.com/Jguer/yay).
 ```sh
 yay gtirb-git
 ```
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake](https://cmake.org/), version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf](https://developers.google.com/protocol-buffers/), version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)](https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest), version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google&apos;s protocol;buffers](https://developers.google.com/protocol-buffers/) (i.e.,
 [protobuf](https://github.com/google/protobuf/wiki)), enabling
 [easy and efficient use from any programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf](https://github.com/google/protobuf/wiki)
 data produced by GTIRB allows for exploration and manipulation in the
 language of your choice. The [Google protocol;buffers](https://developers.google.com/protocol-buffers/) homepage
 lists the languages in which protocol buffers can be used directly;
 users of other languages can convert the protobuf-formatted data to
 JSON format and then use the JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.3-focal
Installed-Size: 422

Package: python3-gtirb-1.10.4
Architecture: amd64
Depends: python3, python3-protobuf, python3-networkx
Priority: optional
Section: devel
Filename: pool/stable/p/python3-gtirb-1.10.4/python3-gtirb-1.10.4_1.10.4-focal_amd64.deb
Size: 93678
SHA256: 6bb4caa93ad3cd3beabd942edb192777a83d25a5906cddb9896aacdc01a41758
SHA1: f6bcf7b672c0d4d366e24d9623b650d7b83d8af3
MD5sum: e644dfe72bd4c05fec65054fa09fb202
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.4-focal
Installed-Size: 419

Package: python3-gtirb-1.10.5
Architecture: amd64
Depends: python3, python3-protobuf, python3-networkx
Priority: optional
Section: devel
Filename: pool/stable/p/python3-gtirb-1.10.5/python3-gtirb-1.10.5_1.10.5-focal_amd64.deb
Size: 95894
SHA256: 4dc842a5d5d878fe7d4e8d0b71cde98b166abcfe64ac64f067c02e730832fc8f
SHA1: bad8d7e0affcadb543842ac9f4c7d7406a2722f7
MD5sum: d2476207f4b9db7ab4c7d195528f4e8f
Description: The GrammaTech Intermediate Representation for Binaries (GTIRB) is a machine code analysis and rewriting data structure.
 # GTIRB
 .
 The GrammaTech Intermediate Representation for Binaries (GTIRB) is a
 machine code analysis and rewriting data structure.  It is intended to
 facilitate the communication of binary IR between programs performing
 binary disassembly, analysis, transformation, and pretty printing.
 GTIRB is modeled on LLVM-IR, and seeks to serve a similar
 functionality of encouraging communication and interoperability
 between tools.
 .
 The remainder of this file describes various aspects of GTIRB:
 - [Structure](#structure)
 - [Installing](#installing)
 - [Building](#building)
 - [Usage](#usage)
 .
 # Structure
 .
 GTIRB has the following structure.  Solid lines denote inheritance.
 Dotted lines denote reference by UUID.
 .
 ![GTIRB Data Structure](.gtirb.svg)
 .
 ## IR
 .
 An instance of GTIRB may include multiple modules (`Module`) which
 represent loadable objects such as executables or libraries, an
 inter-procedural control flow graph (`IPCFG`), and Auxiliary Data tables
 (`AuxData`) which can hold arbitrary analysis results in user-defined
 formats which can easily reference other elements of the IR.  Each
 module holds information such as symbols (`Symbol`) and sections which
 themselves hold the actual bytes and data and code blocks of the
 module.  The CFG consists of basic blocks (`Block`) and control flow
 edges between these blocks.  Each data or code block references a
 range of bytes in a byte interval (`ByteInterval`).  A section may
 hold one large byte interval holding all blocks---if the relative
 positions of blocks in that section are defined---or may hold one byte
 interval per block---if the relative positions of blocks is not
 defined, e.g. for the code blocks in the `.text` section during
 program rewriting.  Each symbol holds a pointer to the block or datum
 it references.
 .
 .
 ## Instructions
 .
 GTIRB explicitly does NOT represent instructions or instruction
 semantics but does provide symbolic operand information and access to
 the bytes.  There are many *intermediate languages* (IL)s for
 representation of instruction semantics (e.g., [BAP][]&apos;s [BIL][],
 [Angr][]&apos;s [Vex][], or [Ghidra][]&apos;s P-code).  GTIRB works with these
 or any other IL by storing instructions generally and efficiently as
 *raw machine-code bytes* and separately storing the symbolic and
 control flow information.  The popular [Capstone][]/[Keystone][]
 decoder/encoder provide an excellent option to read and write
 instructions from/to GTIRB&apos;s machine-code byte representation without
 committing to any particular semantic IL.  By supporting multiple ILs
 and separate storage of analysis results in auxiliary data tables
 GTIRB enables collaboration between independent binary analysis and
 rewriting teams and tools.
 .
 [BAP]: https://github.com/BinaryAnalysisPlatform/bap
 [BIL]: https://github.com/BinaryAnalysisPlatform/bil/releases/download/v0.1/bil.pdf
 [Angr]: http://angr.io
 [Vex]: https://github.com/angr/pyvex
 [Ghidra]: https://www.nsa.gov/resources/everyone/ghidra/
 [Capstone]: https://www.capstone-engine.org
 [Keystone]: https://www.keystone-engine.org
 .
 .
 ## Auxiliary Data
 .
 GTIRB provides for the sharing of additional information,
 e.g. analysis results, in the form of `AuxData` objects.  These can
 store maps and vectors of basic GTIRB types in a portable way. The
 [GTIRB manual][] describes the structure for common types of auxiliary
 data such as function boundary information, type information, or
 results of common analyses in [Standard AuxData Schemata][].
 .
 [GTIRB manual]: https://grammatech.github.io/gtirb/
 [Standard AuxData Schemata]: https://grammatech.github.io/gtirb/md__aux_data.html
 .
 .
 ## UUIDs
 .
 Every element of GTIRB---e.g., modules (`Module`), symbols (`Symbol`),
 and blocks (`Block`)---has a universally unique identifier (UUID).
 UUIDs allow both first-class IR components and AuxData tables to
 reference elements of the IR.
 .
 Instructions and symbolic operands can be addressed by the class
 `Offset` which encapsulates a UUID (that refers to the instruction&apos;s
 block) and an offset.
 .
 .
 # Installing
 .
 Packages currently existing for easily installing GTIRB (and attendant
 tooling including the [ddisasm][] disassembler and [gtirb-pprinter][]
 pretty printer) on Windows, Ubuntu, and Arch Linux.  See below for
 instructions.  Additionally, a public Docker image exists at
 [grammatech/ddisasm][] with all of these tools installed.  GTIRB is
 versioned with Major.Minor.Patch versioning where Major version
 increments will require significant source changes but should be very
 rare, Minor version increments may require small source changes, and
 Patch version increments shouldn&apos;t break any downstream builds.  We do
 not yet provide ABI compatibility across any version changes.
 .
 [ddisasm]: https://github.com/GrammaTech/ddisasm
 [gtirb-pprinter]: https://github.com/GrammaTech/gtirb-pprinter
 [grammatech/ddisasm]: https://hub.docker.com/r/grammatech/ddisasm
 .
 .
 ## Python API
 .
 The GTIRB Python API may be installed with the following.  Note
 however, that installation of the `ddisasm` and `gtirb-pprinter`
 packages as described below is recommended for use with every API.
 ```sh
 pip install gtirb
 ```
 .
 ## Windows
 .
 Pre-built debug and release binaries are available for Windows at:
 [windows-debug/][], and [windows-release/][].  A symbol server for the
 debugging symbols for both the release and debug binaries is available
 at [https://download.grammatech.com/gtirb/files/symbol-server/][].
 For information about how to use a symbol server with your debugger,
 please see [Specify_symbol_locations_and_loading_behavior][] or your
 debugger&apos;s documentation.
 .
 [windows-debug/]: https://download.grammatech.com/gtirb/files/windows-debug/
 [windows-release/]: https://download.grammatech.com/gtirb/files/windows-release/
 [https://download.grammatech.com/gtirb/files/symbol-server/]: https://download.grammatech.com/gtirb/files/symbol-server/
 [Specify_symbol_locations_and_loading_behavior]: https://docs.microsoft.com/en-us/visualstudio/debugger/specify-symbol-dot-pdb-and-source-files-in-the-visual-studio-debugger?view=vs-2019#BKMK_Specify_symbol_locations_and_loading_behavior
 .
 .
 ## Ubuntu
 .
 Packages for Ubuntu 18 and 20 are available in the GTIRB apt
 repository and may be installed per the following instructions.
 .
 First, add GrammaTech&apos;s APT key.
 ```sh
 wget -O - https://download.grammatech.com/gtirb/files/apt-repo/conf/apt.gpg.key | apt-key add -
 ```
 .
 Next update your sources.list file.
 ```sh
 echo &quot;deb https://download.grammatech.com/gtirb/files/apt-repo [distribution] [component]&quot;| sudo tee -a /etc/apt/sources.list
 ```
 Where:
 - `[distribution]` is either `bionic` or `focal` if you&apos;re on Ubuntu 18 or 20 respectively, and
 - `[component]` is either `stable`, which holds the last versioned release, or `unstable`, which holds the HEAD of the repository.
 .
 &gt; **NOTE:** On ubuntu18, gtirb-pprinter and ddisasm packages depend on a boost package from a PPA.  You can add it like this: `add-apt-repository ppa:mhier/libboost-latest`
 .
 Finally update your package database and install the core GTIRB tools:
 ```sh
 sudo apt-get update
 sudo apt-get install libgtirb gtirb-pprinter ddisasm
 ```
 .
 ## Arch Linux
 .
 The Arch User Repository ([AUR][]) includes packages for GTIRB:
 `gtirb-git`, `gtirb-pprinter-git`, and `ddisasm-git`.  The following
 command will build and install all three packages using the popular
 [aur helper][] [yay][].
 ```sh
 yay ddisasm-git
 ```
 .
 [AUR]: https://aur.archlinux.org/
 [aur helper]: https://wiki.archlinux.org/index.php/AUR_helpers
 [yay]: https://github.com/Jguer/yay
 .
 .
 # Building
 .
 GTIRB&apos;s C++ API should successfully build in 64-bits with GCC, Clang,
 and Visual Studio compilers supporting at least C++17.  GTIRB uses
 CMake which must be installed with at least version 3.10.
 .
 The common build process looks like this:
 ```sh
 mkdir build
 cd build
 # Note: You may wish to add some -D arguments to the next command. See below.
 cmake &lt;path/to/gtirb&gt;
 cmake --build .
 # Run the test suite.
 ctest
 ```
 .
 For customizing the GTIRB build, you can get a list of customization options by
 navigating to your build directory and running:
 .
 ```sh
 cmake -LH
 ```
 .
 ## Requirements
 .
 To build and install GTIRB, the following requirements should be installed:
 .
 - [CMake][], version 3.10.0 or higher.
    - Ubuntu 18 provides this version via the APT package `cmake`.
    - Ubuntu 16 and earlier provide out of date versions; build from
      source on those versions.
 - [Protobuf][], version
   3.0.0 or later.
   - Ubuntu 18 provides this version via the APT packages
     `libprotobuf-dev` and `protobuf-compiler`.
   - Ubuntu 16 and earlier provide out of date versions; build from
     source on those versions.
 - Boost [(non-standard Ubuntu package from launchpad.net)][], version 1.67 or later.
   - Ubuntu 18 only has version 1.65 in the standard repository.  See Ubuntu instructions above.
 .
 [CMake]: https://cmake.org/
 [Protobuf]: https://developers.google.com/protocol-buffers/
 [(non-standard Ubuntu package from launchpad.net)]: https://launchpad.net/~mhier/+archive/ubuntu/libboost-latest
 .
 .
 # Usage
 .
 GTIRB is designed to be serialized using [Google protocol buffers][]
 (i.e., [protobuf][]), enabling [easy and efficient use from any;programming language](#using-serialized-gtirb-data).
 .
 GTIRB may also be used through a dedicated API implemented in multiple
 languages. The APIs provide efficient data structures suitable for use
 by binary analysis and rewriting applications; see
 [below](#gtirb-api-implementations) for details.
 .
 [Google protocol buffers]: https://developers.google.com/protocol-buffers/
 [protobuf]: https://github.com/google/protobuf/wiki
 .
 .
 ## Using Serialized GTIRB Data
 .
 The serialized [protobuf][] data produced by GTIRB allows for
 exploration and manipulation in the language of your choice. The
 [Google protocol buffers][] homepage lists the languages in which
 protocol buffers can be used directly; users of other languages can
 convert the protobuf-formatted data to JSON format and then use the
 JSON data in their applications.
 .
 The `proto` directory in this repository contains the protocol buffer
 message type definitions for GTIRB. You can inspect these `.proto`
 files to determine the structure of the various GTIRB message
 types. The top-level message type is `IR`.
 .
 For more details, see [Using Serialized GTIRB Data](PROTOBUF.md).
 .
 .
 ## GTIRB API Implementations
 .
 The GTIRB API is currently available in C++, Python, and Common Lisp.
 There is a *partial* Java API which is not ready for external use.
 For language-independent API information, see [GTIRB;Components](doc/general/ComponentsIndex.md). For information about the
 different API implementations, see:
 .
   - [C++ API](doc/cpp/README.md)
   - [Python API](python/README.md)
   - [Common Lisp API](cl/README.md)
   - Java API **incomplete**
 .
Homepage: https://github.com/GrammaTech/gtirb
Maintainer: gtirb@grammatech.com
Version: 1.10.5-focal
Installed-Size: 427