llvm / llvm / 4fee3cff4d923744aa87dd87175a8b6f91deb4a0 / . / docs / CommandGuide / llvm-bcanalyzer.rst

llvm-bcanalyzer - LLVM bitcode analyzer | |

======================================= | |

SYNOPSIS | |

-------- | |

:program:`llvm-bcanalyzer` [*options*] [*filename*] | |

DESCRIPTION | |

----------- | |

The :program:`llvm-bcanalyzer` command is a small utility for analyzing bitcode | |

files. The tool reads a bitcode file (such as generated with the | |

:program:`llvm-as` tool) and produces a statistical report on the contents of | |

the bitcode file. The tool can also dump a low level but human readable | |

version of the bitcode file. This tool is probably not of much interest or | |

utility except for those working directly with the bitcode file format. Most | |

LLVM users can just ignore this tool. | |

If *filename* is omitted or is ``-``, then :program:`llvm-bcanalyzer` reads its | |

input from standard input. This is useful for combining the tool into a | |

pipeline. Output is written to the standard output. | |

OPTIONS | |

------- | |

.. program:: llvm-bcanalyzer | |

.. option:: -nodetails | |

Causes :program:`llvm-bcanalyzer` to abbreviate its output by writing out only | |

a module level summary. The details for individual functions are not | |

displayed. | |

.. option:: -dump | |

Causes :program:`llvm-bcanalyzer` to dump the bitcode in a human readable | |

format. This format is significantly different from LLVM assembly and | |

provides details about the encoding of the bitcode file. | |

.. option:: -verify | |

Causes :program:`llvm-bcanalyzer` to verify the module produced by reading the | |

bitcode. This ensures that the statistics generated are based on a consistent | |

module. | |

.. option:: -help | |

Print a summary of command line options. | |

EXIT STATUS | |

----------- | |

If :program:`llvm-bcanalyzer` succeeds, it will exit with 0. Otherwise, if an | |

error occurs, it will exit with a non-zero value, usually 1. | |

SUMMARY OUTPUT DEFINITIONS | |

-------------------------- | |

The following items are always printed by llvm-bcanalyzer. They comprize the | |

summary output. | |

**Bitcode Analysis Of Module** | |

This just provides the name of the module for which bitcode analysis is being | |

generated. | |

**Bitcode Version Number** | |

The bitcode version (not LLVM version) of the file read by the analyzer. | |

**File Size** | |

The size, in bytes, of the entire bitcode file. | |

**Module Bytes** | |

The size, in bytes, of the module block. Percentage is relative to File Size. | |

**Function Bytes** | |

The size, in bytes, of all the function blocks. Percentage is relative to File | |

Size. | |

**Global Types Bytes** | |

The size, in bytes, of the Global Types Pool. Percentage is relative to File | |

Size. This is the size of the definitions of all types in the bitcode file. | |

**Constant Pool Bytes** | |

The size, in bytes, of the Constant Pool Blocks Percentage is relative to File | |

Size. | |

**Module Globals Bytes** | |

Ths size, in bytes, of the Global Variable Definitions and their initializers. | |

Percentage is relative to File Size. | |

**Instruction List Bytes** | |

The size, in bytes, of all the instruction lists in all the functions. | |

Percentage is relative to File Size. Note that this value is also included in | |

the Function Bytes. | |

**Compaction Table Bytes** | |

The size, in bytes, of all the compaction tables in all the functions. | |

Percentage is relative to File Size. Note that this value is also included in | |

the Function Bytes. | |

**Symbol Table Bytes** | |

The size, in bytes, of all the symbol tables in all the functions. Percentage is | |

relative to File Size. Note that this value is also included in the Function | |

Bytes. | |

**Dependent Libraries Bytes** | |

The size, in bytes, of the list of dependent libraries in the module. Percentage | |

is relative to File Size. Note that this value is also included in the Module | |

Global Bytes. | |

**Number Of Bitcode Blocks** | |

The total number of blocks of any kind in the bitcode file. | |

**Number Of Functions** | |

The total number of function definitions in the bitcode file. | |

**Number Of Types** | |

The total number of types defined in the Global Types Pool. | |

**Number Of Constants** | |

The total number of constants (of any type) defined in the Constant Pool. | |

**Number Of Basic Blocks** | |

The total number of basic blocks defined in all functions in the bitcode file. | |

**Number Of Instructions** | |

The total number of instructions defined in all functions in the bitcode file. | |

**Number Of Long Instructions** | |

The total number of long instructions defined in all functions in the bitcode | |

file. Long instructions are those taking greater than 4 bytes. Typically long | |

instructions are GetElementPtr with several indices, PHI nodes, and calls to | |

functions with large numbers of arguments. | |

**Number Of Operands** | |

The total number of operands used in all instructions in the bitcode file. | |

**Number Of Compaction Tables** | |

The total number of compaction tables in all functions in the bitcode file. | |

**Number Of Symbol Tables** | |

The total number of symbol tables in all functions in the bitcode file. | |

**Number Of Dependent Libs** | |

The total number of dependent libraries found in the bitcode file. | |

**Total Instruction Size** | |

The total size of the instructions in all functions in the bitcode file. | |

**Average Instruction Size** | |

The average number of bytes per instruction across all functions in the bitcode | |

file. This value is computed by dividing Total Instruction Size by Number Of | |

Instructions. | |

**Maximum Type Slot Number** | |

The maximum value used for a type's slot number. Larger slot number values take | |

more bytes to encode. | |

**Maximum Value Slot Number** | |

The maximum value used for a value's slot number. Larger slot number values take | |

more bytes to encode. | |

**Bytes Per Value** | |

The average size of a Value definition (of any type). This is computed by | |

dividing File Size by the total number of values of any type. | |

**Bytes Per Global** | |

The average size of a global definition (constants and global variables). | |

**Bytes Per Function** | |

The average number of bytes per function definition. This is computed by | |

dividing Function Bytes by Number Of Functions. | |

**# of VBR 32-bit Integers** | |

The total number of 32-bit integers encoded using the Variable Bit Rate | |

encoding scheme. | |

**# of VBR 64-bit Integers** | |

The total number of 64-bit integers encoded using the Variable Bit Rate encoding | |

scheme. | |

**# of VBR Compressed Bytes** | |

The total number of bytes consumed by the 32-bit and 64-bit integers that use | |

the Variable Bit Rate encoding scheme. | |

**# of VBR Expanded Bytes** | |

The total number of bytes that would have been consumed by the 32-bit and 64-bit | |

integers had they not been compressed with the Variable Bit Rage encoding | |

scheme. | |

**Bytes Saved With VBR** | |

The total number of bytes saved by using the Variable Bit Rate encoding scheme. | |

The percentage is relative to # of VBR Expanded Bytes. | |

DETAILED OUTPUT DEFINITIONS | |

--------------------------- | |

The following definitions occur only if the -nodetails option was not given. | |

The detailed output provides additional information on a per-function basis. | |

**Type** | |

The type signature of the function. | |

**Byte Size** | |

The total number of bytes in the function's block. | |

**Basic Blocks** | |

The number of basic blocks defined by the function. | |

**Instructions** | |

The number of instructions defined by the function. | |

**Long Instructions** | |

The number of instructions using the long instruction format in the function. | |

**Operands** | |

The number of operands used by all instructions in the function. | |

**Instruction Size** | |

The number of bytes consumed by instructions in the function. | |

**Average Instruction Size** | |

The average number of bytes consumed by the instructions in the function. | |

This value is computed by dividing Instruction Size by Instructions. | |

**Bytes Per Instruction** | |

The average number of bytes used by the function per instruction. This value | |

is computed by dividing Byte Size by Instructions. Note that this is not the | |

same as Average Instruction Size. It computes a number relative to the total | |

function size not just the size of the instruction list. | |

**Number of VBR 32-bit Integers** | |

The total number of 32-bit integers found in this function (for any use). | |

**Number of VBR 64-bit Integers** | |

The total number of 64-bit integers found in this function (for any use). | |

**Number of VBR Compressed Bytes** | |

The total number of bytes in this function consumed by the 32-bit and 64-bit | |

integers that use the Variable Bit Rate encoding scheme. | |

**Number of VBR Expanded Bytes** | |

The total number of bytes in this function that would have been consumed by | |

the 32-bit and 64-bit integers had they not been compressed with the Variable | |

Bit Rate encoding scheme. | |

**Bytes Saved With VBR** | |

The total number of bytes saved in this function by using the Variable Bit | |

Rate encoding scheme. The percentage is relative to # of VBR Expanded Bytes. | |

SEE ALSO | |

-------- | |

:doc:`/CommandGuide/llvm-dis`, :doc:`/BitCodeFormat` | |