llvm-project/bolt/test/X86/Inputs/blarge.yaml

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

138 lines
12 KiB
YAML
Raw Normal View History

[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Entry: 0x0000000000400CC0
Sections:
- Name: .noplt
Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x00000000004005E0
AddressAlign: 0x0000000000000010
Content: FF35BA122000FF25BC1220000F1F4000FF25BA1220006800000000E9E0FFFFFFFF25B21220006801000000E9D0FFFFFFFF25AA1220006802000000E9C0FFFFFFFF25A21220006803000000E9B0FFFFFFFF259A1220006804000000E9A0FFFFFFFF25921220006805000000E990FFFFFFFF258A1220006806000000E980FFFFFFFF25821220006807000000E970FFFFFFFF257A1220006808000000E960FFFFFF
- Name: .text
Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
Address: 0x0000000000400680
AddressAlign: 0x0000000000000010
Content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
- Name: .rodata
Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ]
Address: 0x0000000000401240
AddressAlign: 0x0000000000000010
Content: 01000200000000002A2A2A2A2A2A2A2A2A2043554249432046554E4354494F4E53202A2A2A2A2A2A2A2A2A2A2A0000002A2A2A2A2A2A2A2A2A20494E54454745522053515220524F4F5453202A2A2A2A2A2A2A2A2A2A2A002A2A2A2A2A2A2A2A2A20414E474C4520434F4E56455253494F4E202A2A2A2A2A2A2A2A2A2A2A000025332E30662064656772656573203D20252E3132662072616469616E730A0000252E3132662072616469616E73203D2025332E306620646567726565730A0000536F6C7574696F6E733A0020256600737172742825336429203D202532640A007371727428256C5829203D2025580A00000000000000F0BF00000000000014400000000000002440000000000000F03F0000000000003EC0000000000000404000000000000025C0000000000000314000000000000012C00000000000003FC000000000000036400000000000000CC000000000008041C06666666666662BC00000000000002840AE47E17A14AE284000000000000008409A999999999937C00000000000001840295C8FC2F5F850C000000000000020C000000000000041400000000000001E40D7A3703D0A572140000000000080464000000000000030403333333333331540333333333333FBBF00000000000028C077BE9F1A2FDDDC3F85EB51B81E85E33F000000000000D03F182D4454FB2109400000000000806640FCA9F1D24D62503F0000000000807640399D52A246DF413F9B0B6097FB21194000000000000000C0182D4454FB211940182D4454FB212940555555555555D53F00004040000010410000D84100005842FFFFFFFFFFFFFF7F0000000000000000
- Name: .dynamic
Type: SHT_DYNAMIC
Flags: [ SHF_WRITE, SHF_ALLOC ]
Address: 0x00000000006016B0
Link: .dynstr
AddressAlign: 0x0000000000000008
Content: 01000000000000000100000000000000010000000000000072000000000000000C00000000000000C0054000000000000D000000000000003412400000000000190000000000000098166000000000001B0000000000000008000000000000001A00000000000000A0166000000000001C000000000000000800000000000000040000000000000048024000000000000500000000000000C803400000000000060000000000000090024000000000000A00000000000000AE000000000000000B000000000000001800000000000000150000000000000000000000000000000300000000000000981860000000000002000000000000000000000000000000140000000000000007000000000000001700000000000000E8044000000000000700000000000000D0044000000000000800000000000000000000000000000009000000000000001800000000000000FEFFFF6F000000009004400000000000FFFFFF6F000000000200000000000000F0FFFF6F000000007604400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Name: .data
Type: SHT_PROGBITS
Flags: [ SHF_WRITE, SHF_ALLOC ]
Address: 0x00000000006018F8
AddressAlign: 0x0000000000000008
Content: '00000000000000000000000000000000'
- Name: .bss
Type: SHT_NOBITS
Flags: [ SHF_WRITE, SHF_ALLOC ]
Address: 0x0000000000601908
AddressAlign: 0x0000000000000001
Size: 0x0000000000000008
Symbols:
- Name: completed.6650
Type: STT_OBJECT
Section: .bss
Value: 0x0000000000601908
Size: 0x0000000000000001
- Name: frame_dummy
Type: STT_FUNC
Section: .text
Value: 0x0000000000400D90
- Name: basicmath_large.c
Type: STT_FILE
- Name: rad2deg.c
Type: STT_FILE
- Name: cubic.c
Type: STT_FILE
- Name: isqrt.c
Type: STT_FILE
- Name: elf-init.c
Type: STT_FILE
- Name: crtstuff.c
Type: STT_FILE
- Name: _DYNAMIC
Type: STT_OBJECT
Section: .dynamic
Value: 0x00000000006016B0
- Name: usqrt
Type: STT_FUNC
Section: .text
Value: 0x0000000000401170
Size: 0x0000000000000043
Binding: STB_GLOBAL
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Name: deg2rad
Type: STT_FUNC
Section: .text
Value: 0x0000000000400DE0
Size: 0x0000000000000011
Binding: STB_GLOBAL
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Name: SolveCubic
Type: STT_FUNC
Section: .text
Value: 0x0000000000400E00
Size: 0x0000000000000368
Binding: STB_GLOBAL
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Name: _start
Type: STT_FUNC
Section: .text
Value: 0x0000000000400CC0
Size: 0x000000000000002A
Binding: STB_GLOBAL
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Name: rad2deg
Type: STT_FUNC
Section: .text
Value: 0x0000000000400DC0
Size: 0x0000000000000011
Binding: STB_GLOBAL
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Name: main
Type: STT_FUNC
Section: .text
Value: 0x0000000000400680
Size: 0x0000000000000640
Binding: STB_GLOBAL
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
DynamicSymbols:
- Name: sqrt
Type: STT_FUNC
Binding: STB_GLOBAL
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
ProgramHeaders:
- Type: PT_PHDR
Flags: [ PF_X, PF_R ]
VAddr: 0x00000000004005E0
PAddr: 0x00000000004005E0
FirstSec: .noplt
LastSec: .noplt
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Type: PT_LOAD
Flags: [ PF_X, PF_R ]
VAddr: 0x00000000004005E0
PAddr: 0x00000000004005E0
FirstSec: .noplt
LastSec: .rodata
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Type: PT_LOAD
Flags: [ PF_R, PF_W ]
VAddr: 0x00000000006018F8
PAddr: 0x00000000006018F8
FirstSec: .data
LastSec: .bss
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
- Type: PT_DYNAMIC
Flags: [ PF_R, PF_W ]
VAddr: 0x00000000006016B0
PAddr: 0x00000000006016B0
FirstSec: .dynamic
LastSec: .dynamic
[BOLT] Add parser for pre-aggregated perf data Summary: The regular perf2bolt aggregation job is to read perf output directly. However, if the data is coming from a database instead of perf, one could write a query to produce a pre-aggregated file. This function deals with this case. The pre-aggregated file contains aggregated LBR data, but without binary knowledge. BOLT will parse it and, using information from the disassembled binary, augment it with fall-through edge frequency information. After this step is finished, this data can be either written to disk to be consumed by BOLT later, or can be used by BOLT immediately if kept in memory. File format syntax: {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count> [<mispred_count>] B - indicates an aggregated branch F - an aggregated fall-through (trace) f - an aggregated fall-through with external origin - used to disambiguate between a return hitting a basic block head and a regular internal jump to the block <start_id> - build id of the object containing the start address. We can skip it for the main binary and use "X" for an unknown object. This will save some space and facilitate human parsing. <start_offset> - hex offset from the object base load address (0 for the main executable unless it's PIE) to the start address. <end_id>, <end_offset> - same for the end address. <count> - total aggregated count of the branch or a fall-through. <mispred_count> - the number of times the branch was mispredicted. Omitted for fall-throughs. Example F 41be50 41be50 3 F 41be90 41be90 4 f 41be90 41be90 7 B 4b1942 39b57f0 3 0 B 4b196f 4b19e0 2 0 (cherry picked from FBD8887182)
2018-07-18 09:31:46 +08:00
...