| # BOLT - a post-link optimizer developed to speed up large applications | |
| ## SYNOPSIS | |
| `llvm-bolt <executable> [-o outputfile] <executable>.bolt [-data=perf.fdata] [options]` | |
| ## OPTIONS | |
| ### Generic options: | |
| - `-h` | |
| Alias for --help | |
| - `--help` | |
| Display available options (--help-hidden for more) | |
| - `--help-hidden` | |
| Display all available options | |
| - `--help-list` | |
| Display list of available options (--help-list-hidden for more) | |
| - `--help-list-hidden` | |
| Display list of all available options | |
| - `--version` | |
| Display the version of this program | |
| ### Output options: | |
| - `--bolt-info` | |
| Write bolt info section in the output binary | |
| - `-o <string>` | |
| output file | |
| - `-w <string>` | |
| Save recorded profile to a file | |
| ### BOLT generic options: | |
| - `--align-text=<uint>` | |
| Alignment of .text section | |
| - `--allow-stripped` | |
| Allow processing of stripped binaries | |
| - `--alt-inst-feature-size=<uint>` | |
| Size of feature field in .altinstructions | |
| - `--alt-inst-has-padlen` | |
| Specify that .altinstructions has padlen field | |
| - `--asm-dump[=<dump folder>]` | |
| Dump function into assembly | |
| - `-b` | |
| Alias for -data | |
| - `--bolt-id=<string>` | |
| Add any string to tag this execution in the output binary via bolt info section | |
| - `--break-funcs=<func1,func2,func3,...>` | |
| List of functions to core dump on (debugging) | |
| - `--check-encoding` | |
| Perform verification of LLVM instruction encoding/decoding. Every instruction | |
| in the input is decoded and re-encoded. If the resulting bytes do not match | |
| the input, a warning message is printed. | |
| - `--comp-dir-override=<string>` | |
| Overrides DW_AT_comp_dir, and provides an alternative base location, which is | |
| used with DW_AT_dwo_name to construct a path to *.dwo files. | |
| - `--create-debug-names-section` | |
| Creates .debug_names section, if the input binary doesn't have it already, for | |
| DWARF5 CU/TUs. | |
| - `--cu-processing-batch-size=<uint>` | |
| Specifies the size of batches for processing CUs. Higher number has better | |
| performance, but more memory usage. Default value is 1. | |
| - `--data=<string>` | |
| data file | |
| - `--data2=<string>` | |
| data file | |
| - `--debug-skeleton-cu` | |
| Prints out offsets for abbrev and debug_info of Skeleton CUs that get patched. | |
| - `--debug-thread-count=<uint>` | |
| Specifies the number of threads to be used when processing DWO debug information. | |
| - `--dot-tooltip-code` | |
| Add basic block instructions as tool tips on nodes | |
| - `--dump-alt-instructions` | |
| Dump Linux alternative instructions info | |
| - `--dump-cg=<string>` | |
| Dump callgraph to the given file | |
| - `--dump-data` | |
| Dump parsed bolt data for debugging | |
| - `--dump-dot-all` | |
| Dump function CFGs to graphviz format after each stage;enable '-print-loops' | |
| for color-coded blocks | |
| - `--dump-dot-func=<func1,func2,func3...>` | |
| Dump function CFGs to graphviz format for specified functions only; | |
| takes function name patterns (regex supported). Note: C++ function names | |
| must be passed using their mangled names | |
| - `--dump-linux-exceptions` | |
| Dump Linux kernel exception table | |
| - `--dump-orc` | |
| Dump raw ORC unwind information (sorted) | |
| - `--dump-para-sites` | |
| Dump Linux kernel paravitual patch sites | |
| - `--dump-pci-fixups` | |
| Dump Linux kernel PCI fixup table | |
| - `--dump-smp-locks` | |
| Dump Linux kernel SMP locks | |
| - `--dump-static-calls` | |
| Dump Linux kernel static calls | |
| - `--dump-static-keys` | |
| Dump Linux kernel static keys jump table | |
| - `--dwarf-output-path=<string>` | |
| Path to where .dwo files or dwp file will be written out to. | |
| - `--dwp=<string>` | |
| Path and name to DWP file. | |
| - `--dyno-stats` | |
| Print execution info based on profile | |
| - `--dyno-stats-all` | |
| Print dyno stats after each stage | |
| - `--dyno-stats-scale=<uint>` | |
| Scale to be applied while reporting dyno stats | |
| - `--enable-bat` | |
| Write BOLT Address Translation tables | |
| - `--fix-branches-with-liveness` | |
| Use liveness analysis to decide whether AArch64 branch inversion must | |
| preserve condition flags | |
| - `--force-data-relocations` | |
| Force relocations to data sections to always be processed | |
| - `--force-patch` | |
| Force patching of original entry points | |
| - `--funcs=<func1,func2,func3,...>` | |
| Limit optimizations to functions from the list | |
| - `--funcs-file=<string>` | |
| File with list of functions to optimize | |
| - `--funcs-file-no-regex=<string>` | |
| File with list of functions to optimize (non-regex) | |
| - `--funcs-no-regex=<func1,func2,func3,...>` | |
| Limit optimizations to functions from the list (non-regex) | |
| - `--hot-data` | |
| Hot data symbols support (relocation mode) | |
| - `--hot-functions-at-end` | |
| If reorder-functions is used, order functions putting hottest last | |
| - `--hot-text` | |
| Generate hot text symbols. Apply this option to a precompiled binary that | |
| manually calls into hugify, such that at runtime hugify call will put hot code | |
| into 2M pages. This requires relocation. | |
| - `--hot-text-move-sections=<sec1,sec2,sec3,...>` | |
| List of sections containing functions used for hugifying hot text. BOLT makes | |
| sure these functions are not placed on the same page as the hot text. | |
| (default='.stub,.mover'). | |
| - `--insert-retpolines` | |
| Run retpoline insertion pass | |
| - `--keep-aranges` | |
| Keep or generate .debug_aranges section if .gdb_index is written | |
| - `--keep-tmp` | |
| Preserve intermediate .o file | |
| - `--lite` | |
| Skip processing of cold functions | |
| - `--log-file=<string>` | |
| Redirect journaling to a file instead of stdout/stderr | |
| - `--long-jump-labels` | |
| Always use long jumps/nops for Linux kernel static keys | |
| - `--match-profile-with-function-hash` | |
| Match profile with function hash | |
| - `--max-data-relocations=<uint>` | |
| Maximum number of data relocations to process | |
| - `--max-funcs=<uint>` | |
| Maximum number of functions to process | |
| - `--no-huge-pages` | |
| Use regular size pages for code alignment | |
| - `--no-threads` | |
| Disable multithreading | |
| - `--pad-funcs=<func1:pad1,func2:pad2,func3:pad3,...>` | |
| List of functions to pad with amount of bytes | |
| - `--print-mappings` | |
| Print mappings in the legend, between characters/blocks and text sections | |
| (default false). | |
| - `--profile-format=<value>` | |
| Format to dump profile output in aggregation mode, default is fdata | |
| - `fdata`: offset-based plaintext format | |
| - `yaml`: dense YAML representation | |
| - `--r11-availability=<value>` | |
| Determine the availability of r11 before indirect branches | |
| - `never`: r11 not available | |
| - `always`: r11 available before calls and jumps | |
| - `abi`: r11 available before calls but not before jumps | |
| - `--relocs` | |
| Use relocations in the binary (default=autodetect) | |
| - `--remove-symtab` | |
| Remove .symtab section | |
| - `--reorder-skip-symbols=<symbol1,symbol2,symbol3,...>` | |
| List of symbol names that cannot be reordered | |
| - `--reorder-symbols=<symbol1,symbol2,symbol3,...>` | |
| List of symbol names that can be reordered | |
| - `--retpoline-lfence` | |
| Determine if lfence instruction should exist in the retpoline | |
| - `--skip-funcs=<func1,func2,func3,...>` | |
| List of functions to skip | |
| - `--skip-funcs-file=<string>` | |
| File with list of functions to skip | |
| - `--strict` | |
| Trust the input to be from a well-formed source | |
| - `--tasks-per-thread=<uint>` | |
| Number of tasks to be created per thread | |
| - `--terminal-trap` | |
| Assume that execution stops at trap instruction | |
| - `--thread-count=<uint>` | |
| Number of threads | |
| - `--top-called-limit=<uint>` | |
| Maximum number of functions to print in top called functions section | |
| - `--trap-avx512` | |
| In relocation mode trap upon entry to any function that uses AVX-512 | |
| instructions | |
| - `--trap-old-code` | |
| Insert traps in old function bodies (relocation mode) | |
| - `--update-debug-sections` | |
| Update DWARF debug sections of the executable | |
| - `--use-gnu-stack` | |
| Use GNU_STACK program header for new segment (workaround for issues with | |
| strip/objcopy) | |
| - `--use-old-text` | |
| Reuse space in old .text if possible (relocation mode) | |
| - `-v <uint>` | |
| Set verbosity level for diagnostic output | |
| ### BOLT optimization options: | |
| - `--align-blocks` | |
| Align basic blocks | |
| - `--align-blocks-min-size=<uint>` | |
| Minimal size of the basic block that should be aligned | |
| - `--align-blocks-threshold=<uint>` | |
| Align only blocks with frequency larger than containing function execution | |
| frequency specified in percent. E.g. 1000 means aligning blocks that are 10 | |
| times more frequently executed than the containing function. | |
| - `--align-functions=<uint>` | |
| Align functions at a given value (relocation mode) | |
| - `--align-functions-max-bytes=<uint>` | |
| Maximum number of bytes to use to align functions | |
| - `--assume-abi` | |
| Assume the ABI is never violated | |
| - `--block-alignment=<uint>` | |
| Boundary to use for alignment of basic blocks | |
| - `--bolt-seed=<uint>` | |
| Seed for randomization | |
| - `--cg-from-perf-data` | |
| Use perf data directly when constructing the call graph for stale functions | |
| - `--cg-ignore-recursive-calls` | |
| Ignore recursive calls when constructing the call graph | |
| - `--cg-use-split-hot-size` | |
| Use hot/cold data on basic blocks to determine hot sizes for call graph | |
| functions | |
| - `--cold-threshold=<uint>` | |
| Tenths of percents of main entry frequency to use as a threshold when | |
| evaluating whether a basic block is cold (0 means it is only considered cold | |
| if the block has zero samples). Default: 0 | |
| - `--elim-link-veneers` | |
| Run veneer elimination pass | |
| - `--eliminate-unreachable` | |
| Eliminate unreachable code | |
| - `--equalize-bb-counts` | |
| Use same count for BBs that should have equivalent count (used in non-LBR and | |
| shrink wrapping) | |
| - `--execution-count-threshold=<uint>` | |
| Perform profiling accuracy-sensitive optimizations only if function execution | |
| count >= the threshold (default: 0) | |
| - `--fix-block-counts` | |
| Adjust block counts based on outgoing branch counts | |
| - `--fix-func-counts` | |
| Adjust function counts based on basic blocks execution count | |
| - `--force-inline=<func1,func2,func3,...>` | |
| List of functions to always consider for inlining | |
| - `--frame-opt=<value>` | |
| Optimize stack frame accesses | |
| - `none`: do not perform frame optimization | |
| - `hot`: perform FOP on hot functions | |
| - `all`: perform FOP on all functions | |
| - `--frame-opt-rm-stores` | |
| Apply additional analysis to remove stores (experimental) | |
| - `--function-order=<string>` | |
| File containing an ordered list of functions to use for function reordering | |
| - `--generate-function-order=<string>` | |
| File to dump the ordered list of functions to use for function reordering | |
| - `--generate-link-sections=<string>` | |
| Generate a list of function sections in a format suitable for inclusion in a | |
| linker script | |
| - `--group-stubs` | |
| Share stubs across functions | |
| - `--hugify` | |
| Automatically put hot code on 2MB page(s) (hugify) at runtime. No manual call | |
| to hugify is needed in the binary (which is what --hot-text relies on). | |
| - `--icf=<value>` | |
| Fold functions with identical code | |
| - `all`: Enable identical code folding | |
| - `none`: Disable identical code folding (default) | |
| - `safe`: Enable safe identical code folding | |
| - `--icp` | |
| Alias for --indirect-call-promotion | |
| - `--icp-calls-remaining-percent-threshold=<uint>` | |
| The percentage threshold against remaining unpromoted indirect call count for | |
| the promotion for calls | |
| - `--icp-calls-topn` | |
| Alias for --indirect-call-promotion-calls-topn | |
| - `--icp-calls-total-percent-threshold=<uint>` | |
| The percentage threshold against total count for the promotion for calls | |
| - `--icp-eliminate-loads` | |
| Enable load elimination using memory profiling data when performing ICP | |
| - `--icp-funcs=<func1,func2,func3,...>` | |
| List of functions to enable ICP for | |
| - `--icp-inline` | |
| Only promote call targets eligible for inlining | |
| - `--icp-jt-remaining-percent-threshold=<uint>` | |
| The percentage threshold against remaining unpromoted indirect call count for | |
| the promotion for jump tables | |
| - `--icp-jt-targets` | |
| Alias for --icp-jump-tables-targets | |
| - `--icp-jt-topn` | |
| Alias for --indirect-call-promotion-jump-tables-topn | |
| - `--icp-jt-total-percent-threshold=<uint>` | |
| The percentage threshold against total count for the promotion for jump tables | |
| - `--icp-jump-tables-targets` | |
| For jump tables, optimize indirect jmp targets instead of indices | |
| - `--icp-mp-threshold` | |
| Alias for --indirect-call-promotion-mispredict-threshold | |
| - `--icp-old-code-sequence` | |
| Use old code sequence for promoted calls | |
| - `--icp-top-callsites=<uint>` | |
| Optimize hottest calls until at least this percentage of all indirect calls | |
| frequency is covered. 0 = all callsites | |
| - `--icp-topn` | |
| Alias for --indirect-call-promotion-topn | |
| - `--icp-use-mp` | |
| Alias for --indirect-call-promotion-use-mispredicts | |
| - `--indirect-call-promotion=<value>` | |
| Indirect call promotion | |
| - `none`: do not perform indirect call promotion | |
| - `calls`: perform ICP on indirect calls | |
| - `jump-tables`: perform ICP on jump tables | |
| - `all`: perform ICP on calls and jump tables | |
| - `--indirect-call-promotion-calls-topn=<uint>` | |
| Limit number of targets to consider when doing indirect call promotion on | |
| calls. 0 = no limit | |
| - `--indirect-call-promotion-jump-tables-topn=<uint>` | |
| Limit number of targets to consider when doing indirect call promotion on jump | |
| tables. 0 = no limit | |
| - `--indirect-call-promotion-topn=<uint>` | |
| Limit number of targets to consider when doing indirect call promotion. 0 = no | |
| limit | |
| - `--indirect-call-promotion-use-mispredicts` | |
| Use misprediction frequency for determining whether or not ICP should be | |
| applied at a callsite. The -indirect-call-promotion-mispredict-threshold | |
| value will be used by this heuristic | |
| - `--infer-fall-throughs` | |
| Infer execution count for fall-through blocks | |
| - `--infer-stale-profile` | |
| Infer counts from stale profile data. | |
| - `--inline-all` | |
| Inline all functions | |
| - `--inline-ap` | |
| Adjust function profile after inlining | |
| - `--inline-limit=<uint>` | |
| Maximum number of call sites to inline | |
| - `--inline-max-iters=<uint>` | |
| Maximum number of inline iterations | |
| - `--inline-memcpy` | |
| Inline memcpy using optimized instruction sequences (X86: 'rep movsb', AArch64: width-optimized register operations) | |
| - `--inline-small-functions` | |
| Inline functions if increase in size is less than defined by -inline-small- | |
| functions-bytes | |
| - `--inline-small-functions-bytes=<uint>` | |
| Max number of bytes for the function to be considered small for inlining | |
| purposes | |
| - `--instrument` | |
| Instrument code to generate accurate profile data | |
| - `--iterative-guess` | |
| In non-LBR mode, guess edge counts using iterative technique | |
| - `--jt-footprint-optimize-for-icache` | |
| With jt-footprint-reduction, only process PIC jumptables and turn off other | |
| transformations that increase code size | |
| - `--jt-footprint-reduction` | |
| Make jump tables size smaller at the cost of using more instructions at jump | |
| sites | |
| - `--jump-tables=<value>` | |
| Jump tables support (default=basic) | |
| - `none`: do not optimize functions with jump tables | |
| - `basic`: optimize functions with jump tables | |
| - `move`: move jump tables to a separate section | |
| - `split`: split jump tables section into hot and cold based on function | |
| execution frequency | |
| - `aggressive`: aggressively split jump tables section based on usage of the | |
| tables | |
| - `--keep-nops` | |
| Keep no-op instructions. By default they are removed. | |
| - `--lite-threshold-count=<uint>` | |
| Similar to '-lite-threshold-pct' but specify threshold using absolute function | |
| call count. I.e. limit processing to functions executed at least the specified | |
| number of times. | |
| - `--lite-threshold-pct=<uint>` | |
| Threshold (in percent) for selecting functions to process in lite mode. Higher | |
| threshold means fewer functions to process. E.g threshold of 90 means only top | |
| 10 percent of functions with profile will be processed. | |
| - `--match-with-call-graph` | |
| Match functions with call graph | |
| - `--memcpy1-spec=<func1,func2:cs1:cs2,func3:cs1,...>` | |
| List of functions with call sites for which to specialize memcpy() for size 1 | |
| - `--min-branch-clusters` | |
| Use a modified clustering algorithm geared towards minimizing branches | |
| - `--name-similarity-function-matching-threshold=<uint>` | |
| Match functions using namespace and edit distance. | |
| - `--no-inline` | |
| Disable all inlining (overrides other inlining options) | |
| - `--no-scan` | |
| Do not scan cold functions for external references (may result in slower binary) | |
| - `--peepholes=<value>` | |
| Enable peephole optimizations | |
| - `none`: disable peepholes | |
| - `double-jumps`: remove double jumps when able | |
| - `tailcall-traps`: insert tail call traps | |
| - `useless-branches`: remove useless conditional branches | |
| - `all`: enable all peephole optimizations | |
| - `--plt=<value>` | |
| Optimize PLT calls (requires linking with -znow on non-x86 architectures) | |
| - `none`: do not optimize PLT calls | |
| - `hot`: optimize executed (hot) PLT calls | |
| - `all`: optimize all PLT calls | |
| - `--preserve-blocks-alignment` | |
| Try to preserve basic block alignment | |
| - `--profile-ignore-hash` | |
| Ignore hash while reading function profile | |
| - `--profile-use-dfs` | |
| Use DFS order for YAML profile | |
| - `--reg-reassign` | |
| Reassign registers so as to avoid using REX prefixes in hot code | |
| - `--reorder-blocks=<value>` | |
| Change layout of basic blocks in a function | |
| - `none`: do not reorder basic blocks | |
| - `reverse`: layout blocks in reverse order | |
| - `normal`: perform optimal layout based on profile | |
| - `branch-predictor`: perform optimal layout prioritizing branch predictions | |
| - `cache`: perform optimal layout prioritizing I-cache behavior | |
| - `cache+`: perform layout optimizing I-cache behavior | |
| - `ext-tsp`: perform layout optimizing I-cache behavior | |
| - `cluster-shuffle`: perform random layout of clusters | |
| - `--reorder-data=<section1,section2,section3,...>` | |
| List of sections to reorder | |
| - `--reorder-data-algo=<value>` | |
| Algorithm used to reorder data sections | |
| - `count`: sort hot data by read counts | |
| - `funcs`: sort hot data by hot function usage and count | |
| - `--reorder-data-inplace` | |
| Reorder data sections in place | |
| - `--reorder-data-max-bytes=<uint>` | |
| Maximum number of bytes to reorder | |
| - `--reorder-data-max-symbols=<uint>` | |
| Maximum number of symbols to reorder | |
| - `--reorder-functions=<value>` | |
| Reorder and cluster functions (works only with relocations) | |
| - `none`: do not reorder functions | |
| - `exec-count`: order by execution count | |
| - `hfsort`: use hfsort algorithm | |
| - `hfsort+`: use cache-directed sort | |
| - `cdsort`: use cache-directed sort | |
| - `pettis-hansen`: use Pettis-Hansen algorithm | |
| - `random`: reorder functions randomly | |
| - `user`: use function order specified by -function-order | |
| - `--reorder-functions-use-hot-size` | |
| Use a function's hot size when doing clustering | |
| - `--report-bad-layout=<uint>` | |
| Print top <uint> functions with suboptimal code layout on input | |
| - `--report-stale` | |
| Print the list of functions with stale profile | |
| - `--runtime-hugify-lib=<string>` | |
| Specify file name of the runtime hugify library | |
| - `--runtime-instrumentation-lib=<string>` | |
| Specify file name of the runtime instrumentation library | |
| - `--runtime-lib-init-hook=<value>` | |
| Primary target for hooking runtime library initialization, used in | |
| fallback order of availability in input binary (entry_point -> init | |
| -> init_array) (default: entry_point) | |
| - `entry_point`: use ELF Header Entry Point | |
| - `init`: use ELF DT_INIT entry | |
| - `init_array`: use ELF .init_array entry | |
| - `--sctc-mode=<value>` | |
| Mode for simplify conditional tail calls | |
| - `always`: always perform sctc | |
| - `preserve`: only perform sctc when branch direction is preserved | |
| - `heuristic`: use branch prediction data to control sctc | |
| - `--sequential-disassembly` | |
| Performs disassembly sequentially | |
| - `--shrink-wrapping-threshold=<uint>` | |
| Percentage of prologue execution count to use as threshold when evaluating | |
| whether a block is cold enough to be profitable to move eligible spills there | |
| - `--simplify-conditional-tail-calls` | |
| Simplify conditional tail calls by removing unnecessary jumps | |
| - `--simplify-rodata-loads` | |
| Simplify loads from read-only sections by replacing the memory operand with | |
| the constant found in the corresponding section | |
| - `--split-align-threshold=<uint>` | |
| When deciding to split a function, apply this alignment while doing the size | |
| comparison (see -split-threshold). Default value: 2. | |
| - `--split-all-cold` | |
| Outline as many cold basic blocks as possible | |
| - `--split-eh` | |
| Split C++ exception handling code | |
| - `--split-functions` | |
| Split functions into fragments | |
| - `--split-strategy=<value>` | |
| Strategy used to partition blocks into fragments | |
| - `profile2`: split each function into a hot and cold fragment using profiling | |
| information | |
| - `cdsplit`: split each function into a hot, warm, and cold fragment using | |
| profiling information | |
| - `random2`: split each function into a hot and cold fragment at a randomly | |
| chosen split point (ignoring any available profiling information) | |
| - `randomN`: split each function into N fragments at a randomly chosen split | |
| points (ignoring any available profiling information) | |
| - `all`: split all basic blocks of each function into fragments such that each | |
| fragment contains exactly a single basic block | |
| - `--split-threshold=<uint>` | |
| Split function only if its main size is reduced by more than given amount of | |
| bytes. Default value: 0, i.e. split iff the size is reduced. Note that on some | |
| architectures the size can increase after splitting. | |
| - `--stale-matching-max-func-size=<uint>` | |
| The maximum size of a function to consider for inference. | |
| - `--stale-matching-min-matched-block=<uint>` | |
| Percentage threshold of matched basic blocks at which stale profile inference | |
| is executed. | |
| - `--stale-threshold=<uint>` | |
| Maximum percentage of stale functions to tolerate (default: 100) | |
| - `--stoke` | |
| Turn on the stoke analysis | |
| - `--strip-rep-ret` | |
| Strip 'repz' prefix from 'repz retq' sequence (on by default) | |
| - `--tail-duplication=<value>` | |
| Duplicate unconditional branches that cross a cache line | |
| - `none`: do not apply | |
| - `aggressive`: aggressive strategy | |
| - `moderate`: moderate strategy | |
| - `cache`: cache-aware duplication strategy | |
| - `--tsp-threshold=<uint>` | |
| Maximum number of hot basic blocks in a function for which to use a precise | |
| TSP solution while re-ordering basic blocks | |
| - `--use-aggr-reg-reassign` | |
| Use register liveness analysis to try to find more opportunities for -reg- | |
| reassign optimization | |
| - `--use-compact-aligner` | |
| Use compact approach for aligning functions | |
| - `--use-edge-counts` | |
| Use edge count data when doing clustering | |
| - `--verify-cfg` | |
| Verify the CFG after every pass | |
| - `--x86-align-branch-boundary-hot-only` | |
| Only apply branch boundary alignment in hot code | |
| - `--x86-strip-redundant-address-size` | |
| Remove redundant Address-Size override prefix | |
| ### BOLT instrumentation options: | |
| `llvm-bolt <executable> -instrument [-o outputfile] <instrumented-executable>` | |
| - `--conservative-instrumentation` | |
| Disable instrumentation optimizations that sacrifice profile accuracy (for | |
| debugging, default: false) | |
| - `--instrument-calls` | |
| Record profile for inter-function control flow activity (default: true) | |
| - `--instrument-hot-only` | |
| Only insert instrumentation on hot functions (needs profile, default: false) | |
| - `--instrumentation-binpath=<string>` | |
| Path to instrumented binary in case if /proc/self/map_files is not accessible | |
| due to access restriction issues | |
| - `--instrumentation-file=<string>` | |
| File name where instrumented profile will be saved (default: /tmp/prof.fdata) | |
| - `--instrumentation-file-append-pid` | |
| Append PID to saved profile file name (default: false) | |
| - `--instrumentation-no-counters-clear` | |
| Don't clear counters across dumps (use with instrumentation-sleep-time option) | |
| - `--instrumentation-sleep-time=<uint>` | |
| Interval between profile writes (default: 0 = write only at program end). | |
| This is useful for service workloads when you want to dump profile every X | |
| minutes or if you are killing the program and the profile is not being dumped | |
| at the end. | |
| - `--instrumentation-wait-forks` | |
| Wait until all forks of instrumented process will finish (use with | |
| instrumentation-sleep-time option) | |
| ### BOLT printing options: | |
| - `--print-aliases` | |
| Print aliases when printing objects | |
| - `--print-all` | |
| Print functions after each stage | |
| - `--print-cfg` | |
| Print functions after CFG construction | |
| - `--print-debug-info` | |
| Print debug info when printing functions | |
| - `--print-disasm` | |
| Print function after disassembly | |
| - `--print-dyno-opcode-stats=<uint>` | |
| Print per instruction opcode dyno stats and the functionnames:BB offsets of | |
| the nth highest execution counts | |
| - `--print-dyno-stats-only` | |
| While printing functions output dyno-stats and skip instructions | |
| - `--print-exceptions` | |
| Print exception handling data | |
| - `--print-globals` | |
| Print global symbols after disassembly | |
| - `--print-jump-tables` | |
| Print jump tables | |
| - `--print-loops` | |
| Print loop related information | |
| - `--print-mem-data` | |
| Print memory data annotations when printing functions | |
| - `--print-normalized` | |
| Print functions after CFG is normalized | |
| - `--print-only=<func1,func2,func3,...>` | |
| List of functions to print | |
| - `--print-orc` | |
| Print ORC unwind information for instructions | |
| - `--print-profile` | |
| Print functions after attaching profile | |
| - `--print-profile-stats` | |
| Print profile quality/bias analysis | |
| - `--print-pseudo-probes=<value>` | |
| Print pseudo probe info | |
| - `decode`: decode probes section from binary | |
| - `address_conversion`: update address2ProbesMap with output block address | |
| - `encoded_probes`: display the encoded probes in binary section | |
| - `all`: enable all debugging printout | |
| - `--print-relocations` | |
| Print relocations when printing functions/objects | |
| - `--print-reordered-data` | |
| Print section contents after reordering | |
| - `--print-retpoline-insertion` | |
| Print functions after retpoline insertion pass | |
| - `--print-sdt` | |
| Print all SDT markers | |
| - `--print-sections` | |
| Print all registered sections | |
| - `--print-unknown` | |
| Print names of functions with unknown control flow | |
| - `--time-build` | |
| Print time spent constructing binary functions | |
| - `--time-rewrite` | |
| Print time spent in rewriting passes | |
| - `--print-after-branch-fixup` | |
| Print function after fixing local branches | |
| - `--print-after-jt-footprint-reduction` | |
| Print function after jt-footprint-reduction pass | |
| - `--print-after-lowering` | |
| Print function after instruction lowering | |
| - `--print-cache-metrics` | |
| Calculate and print various metrics for instruction cache | |
| - `--print-clusters` | |
| Print clusters | |
| - `--print-estimate-edge-counts` | |
| Print function after edge counts are set for no-LBR profile | |
| - `--print-finalized` | |
| Print function after CFG is finalized | |
| - `--print-fix-relaxations` | |
| Print functions after fix relaxations pass | |
| - `--print-fix-riscv-calls` | |
| Print functions after fix RISCV calls pass | |
| - `--print-fop` | |
| Print functions after frame optimizer pass | |
| - `--print-function-statistics=<uint>` | |
| Print statistics about basic block ordering | |
| - `--print-icf` | |
| Print functions after ICF optimization | |
| - `--print-icp` | |
| Print functions after indirect call promotion | |
| - `--print-inline` | |
| Print functions after inlining optimization | |
| - `--print-large-functions` | |
| Print functions that could not be overwritten due to excessive size | |
| - `--print-longjmp` | |
| Print functions after longjmp pass | |
| - `--print-optimize-bodyless` | |
| Print functions after bodyless optimization | |
| - `--print-output-address-range` | |
| Print output address range for each basic block in the function | |
| whenBinaryFunction::print is called | |
| - `--print-peepholes` | |
| Print functions after peephole optimization | |
| - `--print-plt` | |
| Print functions after PLT optimization | |
| - `--print-regreassign` | |
| Print functions after regreassign pass | |
| - `--print-reordered` | |
| Print functions after layout optimization | |
| - `--print-reordered-functions` | |
| Print functions after clustering | |
| - `--print-sctc` | |
| Print functions after conditional tail call simplification | |
| - `--print-simplify-rodata-loads` | |
| Print functions after simplification of RO data loads | |
| - `--print-sorted-by=<value>` | |
| Print functions sorted by order of dyno stats | |
| - `executed-forward-branches`: executed forward branches | |
| - `taken-forward-branches`: taken forward branches | |
| - `executed-backward-branches`: executed backward branches | |
| - `taken-backward-branches`: taken backward branches | |
| - `executed-unconditional-branches`: executed unconditional branches | |
| - `all-function-calls`: all function calls | |
| - `indirect-calls`: indirect calls | |
| - `PLT-calls`: PLT calls | |
| - `executed-instructions`: executed instructions | |
| - `executed-load-instructions`: executed load instructions | |
| - `executed-store-instructions`: executed store instructions | |
| - `taken-jump-table-branches`: taken jump table branches | |
| - `taken-unknown-indirect-branches`: taken unknown indirect branches | |
| - `total-branches`: total branches | |
| - `taken-branches`: taken branches | |
| - `non-taken-conditional-branches`: non-taken conditional branches | |
| - `taken-conditional-branches`: taken conditional branches | |
| - `all-conditional-branches`: all conditional branches | |
| - `linker-inserted-veneer-calls`: linker-inserted veneer calls | |
| - `all`: sorted by all names | |
| - `--print-sorted-by-order=<value>` | |
| Use ascending or descending order when printing functions ordered by dyno stats | |
| - `--print-split` | |
| Print functions after code splitting | |
| - `--print-stoke` | |
| Print functions after stoke analysis | |
| - `--print-uce` | |
| Print functions after unreachable code elimination | |
| - `--print-veneer-elimination` | |
| Print functions after veneer elimination pass | |
| - `--time-opts` | |
| Print time spent in each optimization | |
| - `--print-all-options` | |
| Print all option values after command line parsing | |
| - `--print-options` | |
| Print non-default options after command line parsing |