github/verilator
1
0
Fork 1
mirror of https://github.com/verilator/verilator.git synced 2025-01-28 09:14:13 +00:00
Code Issues Packages Projects Releases Wiki Activity
5869fdf7f6
verilator/test_regress/t/t_cover_line_trace.out

527 lines
19 KiB
Plaintext
Raw Normal View History

Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$version Generated by VerilatedVcd $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$date Sat Dec 18 13:32:31 2021 $end
$timescale 1ps $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$scope module top $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$scope module t $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
$var wire 32 & cyc [31:0] $end
$var wire 8 ' cyc_copy [7:0] $end
$var wire 1 % toggle $end
$var wire 32 ; vlCoverageLineTrace_t_cover_line__102_elsif [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 < vlCoverageLineTrace_t_cover_line__105_elsif [31:0] $end
$var wire 32 = vlCoverageLineTrace_t_cover_line__112_else [31:0] $end
$var wire 32 > vlCoverageLineTrace_t_cover_line__112_if [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 X vlCoverageLineTrace_t_cover_line__119_block [31:0] $end
$var wire 32 # vlCoverageLineTrace_t_cover_line__15_block [31:0] $end
$var wire 32 $ vlCoverageLineTrace_t_cover_line__18_block [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 ( vlCoverageLineTrace_t_cover_line__47_block [31:0] $end
$var wire 32 ) vlCoverageLineTrace_t_cover_line__48_else [31:0] $end
$var wire 32 * vlCoverageLineTrace_t_cover_line__48_if [31:0] $end
$var wire 32 + vlCoverageLineTrace_t_cover_line__52_else [31:0] $end
$var wire 32 , vlCoverageLineTrace_t_cover_line__52_if [31:0] $end
$var wire 32 - vlCoverageLineTrace_t_cover_line__53_else [31:0] $end
$var wire 32 . vlCoverageLineTrace_t_cover_line__53_if [31:0] $end
$var wire 32 / vlCoverageLineTrace_t_cover_line__58_else [31:0] $end
$var wire 32 0 vlCoverageLineTrace_t_cover_line__58_if [31:0] $end
$var wire 32 1 vlCoverageLineTrace_t_cover_line__59_else [31:0] $end
$var wire 32 2 vlCoverageLineTrace_t_cover_line__59_if [31:0] $end
$var wire 32 3 vlCoverageLineTrace_t_cover_line__65_else [31:0] $end
$var wire 32 4 vlCoverageLineTrace_t_cover_line__65_if [31:0] $end
$var wire 32 5 vlCoverageLineTrace_t_cover_line__66_else [31:0] $end
$var wire 32 6 vlCoverageLineTrace_t_cover_line__66_if [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 7 vlCoverageLineTrace_t_cover_line__75_elsif [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 8 vlCoverageLineTrace_t_cover_line__79_elsif [31:0] $end
$var wire 32 9 vlCoverageLineTrace_t_cover_line__83_else [31:0] $end
$var wire 32 : vlCoverageLineTrace_t_cover_line__83_if [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 ] vlCoverageLineTrace_t_cover_line__92_block [31:0] $end
$var wire 32 ^ vlCoverageLineTrace_t_cover_line__93_block [31:0] $end
$var wire 32 _ vlCoverageLineTrace_t_cover_line__96_block [31:0] $end
$var wire 32 ` vlCoverageLineTrace_t_cover_line__97_block [31:0] $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$scope module a1 $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
$var wire 1 % toggle $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 ? vlCoverageLineTrace_t_cover_line__132_block [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 @ vlCoverageLineTrace_t_cover_line__133_else [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 A vlCoverageLineTrace_t_cover_line__133_if [31:0] $end
$var wire 32 B vlCoverageLineTrace_t_cover_line__137_else [31:0] $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$upscope $end
$scope module a2 $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
$var wire 1 % toggle $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 C vlCoverageLineTrace_t_cover_line__132_block [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 D vlCoverageLineTrace_t_cover_line__133_else [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 E vlCoverageLineTrace_t_cover_line__133_if [31:0] $end
$var wire 32 F vlCoverageLineTrace_t_cover_line__137_else [31:0] $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$upscope $end
$scope module b1 $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
$var wire 1 % toggle $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 K vlCoverageLineTrace_t_cover_line__156_block [31:0] $end
$var wire 32 L vlCoverageLineTrace_t_cover_line__158_else [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 b vlCoverageLineTrace_t_cover_line__158_if [31:0] $end
$var wire 32 M vlCoverageLineTrace_t_cover_line__162_else [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 N vlCoverageLineTrace_t_cover_line__162_if [31:0] $end
$var wire 32 O vlCoverageLineTrace_t_cover_line__166_else [31:0] $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$upscope $end
$scope module b2 $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
$var wire 1 % toggle $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 P vlCoverageLineTrace_t_cover_line__156_block [31:0] $end
$var wire 32 Q vlCoverageLineTrace_t_cover_line__158_else [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 c vlCoverageLineTrace_t_cover_line__158_if [31:0] $end
$var wire 32 R vlCoverageLineTrace_t_cover_line__162_else [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 S vlCoverageLineTrace_t_cover_line__162_if [31:0] $end
$var wire 32 T vlCoverageLineTrace_t_cover_line__166_else [31:0] $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$upscope $end
$scope module o1 $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
$var wire 1 % toggle $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 G vlCoverageLineTrace_t_cover_line__220_block [31:0] $end
$var wire 32 H vlCoverageLineTrace_t_cover_line__221_else [31:0] $end
$var wire 32 I vlCoverageLineTrace_t_cover_line__221_if [31:0] $end
$var wire 32 J vlCoverageLineTrace_t_cover_line__224_else [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 a vlCoverageLineTrace_t_cover_line__224_if [31:0] $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$upscope $end
$scope module t1 $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 1 W clk $end
$var wire 1 % toggle $end
$var wire 32 U vlCoverageLineTrace_t_cover_line__187_block [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 Y vlCoverageLineTrace_t_cover_line__191_block [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 Z vlCoverageLineTrace_t_cover_line__194_else [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 [ vlCoverageLineTrace_t_cover_line__194_if [31:0] $end
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
$var wire 32 V vlCoverageLineTrace_t_cover_line__197_else [31:0] $end
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
$var wire 32 \ vlCoverageLineTrace_t_cover_line__197_if [31:0] $end
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
$upscope $end
$upscope $end
$upscope $end
$enddefinitions $end
#0
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 #
b00000000000000000000000000000001 $
0%
b00000000000000000000000000000001 &
b00000001 '
b00000000000000000000000000000000 (
b00000000000000000000000000000000 )
b00000000000000000000000000000000 *
b00000000000000000000000000000000 +
b00000000000000000000000000000000 ,
b00000000000000000000000000000000 -
b00000000000000000000000000000000 .
b00000000000000000000000000000000 /
b00000000000000000000000000000000 0
b00000000000000000000000000000000 1
b00000000000000000000000000000000 2
b00000000000000000000000000000000 3
b00000000000000000000000000000000 4
b00000000000000000000000000000000 5
b00000000000000000000000000000000 6
b00000000000000000000000000000000 7
b00000000000000000000000000000000 8
b00000000000000000000000000000000 9
b00000000000000000000000000000000 :
Add lint_off -match waivers (#2102) * Add more directives to configuration files Allow to set the same directives in configuration files that can also be set by comment attributes (such as /* verilator public */ etc). * Add support for lint messsage waivers Add configuration file switch '-match' for lint_off. It takes a string with wildcards allowed and warnings will be matched against it (if rule and file also match). If it matches, the warning is waived. Fixes #1649 and #1514 Closes #2072
2020-01-12 09:03:17 +00:00
b00000000000000000000000000000000 ;
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000000 <
b00000000000000000000000000000000 =
b00000000000000000000000000000000 >
b00000000000000000000000000000000 ?
b00000000000000000000000000000000 @
b00000000000000000000000000000000 A
b00000000000000000000000000000000 B
Add lint_off -match waivers (#2102) * Add more directives to configuration files Allow to set the same directives in configuration files that can also be set by comment attributes (such as /* verilator public */ etc). * Add support for lint messsage waivers Add configuration file switch '-match' for lint_off. It takes a string with wildcards allowed and warnings will be matched against it (if rule and file also match). If it matches, the warning is waived. Fixes #1649 and #1514 Closes #2072
2020-01-12 09:03:17 +00:00
b00000000000000000000000000000000 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000000 D
b00000000000000000000000000000000 E
b00000000000000000000000000000000 F
b00000000000000000000000000000000 G
b00000000000000000000000000000000 H
b00000000000000000000000000000000 I
b00000000000000000000000000000000 J
Add lint_off -match waivers (#2102) * Add more directives to configuration files Allow to set the same directives in configuration files that can also be set by comment attributes (such as /* verilator public */ etc). * Add support for lint messsage waivers Add configuration file switch '-match' for lint_off. It takes a string with wildcards allowed and warnings will be matched against it (if rule and file also match). If it matches, the warning is waived. Fixes #1649 and #1514 Closes #2072
2020-01-12 09:03:17 +00:00
b00000000000000000000000000000000 K
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000000 L
b00000000000000000000000000000000 M
b00000000000000000000000000000000 N
b00000000000000000000000000000000 O
b00000000000000000000000000000000 P
b00000000000000000000000000000000 Q
b00000000000000000000000000000000 R
Add lint_off -match waivers (#2102) * Add more directives to configuration files Allow to set the same directives in configuration files that can also be set by comment attributes (such as /* verilator public */ etc). * Add support for lint messsage waivers Add configuration file switch '-match' for lint_off. It takes a string with wildcards allowed and warnings will be matched against it (if rule and file also match). If it matches, the warning is waived. Fixes #1649 and #1514 Closes #2072
2020-01-12 09:03:17 +00:00
b00000000000000000000000000000000 S
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000000 T
b00000000000000000000000000000000 U
b00000000000000000000000000000000 V
0W
b00000000000000000000000000000000 X
b00000000000000000000000000000000 Y
b00000000000000000000000000000000 Z
Add lint_off -match waivers (#2102) * Add more directives to configuration files Allow to set the same directives in configuration files that can also be set by comment attributes (such as /* verilator public */ etc). * Add support for lint messsage waivers Add configuration file switch '-match' for lint_off. It takes a string with wildcards allowed and warnings will be matched against it (if rule and file also match). If it matches, the warning is waived. Fixes #1649 and #1514 Closes #2072
2020-01-12 09:03:17 +00:00
b00000000000000000000000000000000 [
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000000 \
b00000000000000000000000000000000 ]
b00000000000000000000000000000000 ^
b00000000000000000000000000000000 _
b00000000000000000000000000000000 `
b00000000000000000000000000000000 a
b00000000000000000000000000000000 b
Add lint_off -match waivers (#2102) * Add more directives to configuration files Allow to set the same directives in configuration files that can also be set by comment attributes (such as /* verilator public */ etc). * Add support for lint messsage waivers Add configuration file switch '-match' for lint_off. It takes a string with wildcards allowed and warnings will be matched against it (if rule and file also match). If it matches, the warning is waived. Fixes #1649 and #1514 Closes #2072
2020-01-12 09:03:17 +00:00
b00000000000000000000000000000000 c
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#10
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 &
b00000010 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 (
b00000000000000000000000000000001 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 +
b00000000000000000000000000000001 -
b00000000000000000000000000000001 /
b00000000000000000000000000000001 1
b00000000000000000000000000000001 3
b00000000000000000000000000000001 5
b00000000000000000000000000000001 9
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 =
b00000000000000000000000000000001 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 @
b00000000000000000000000000000001 B
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 D
b00000000000000000000000000000001 F
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 G
b00000000000000000000000000000001 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 M
b00000000000000000000000000000001 O
b00000000000000000000000000000001 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 R
b00000000000000000000000000000001 T
b00000000000000000000000000000001 U
b00000000000000000000000000000001 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 Z
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#15
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#20
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 &
b00000011 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000010 (
b00000000000000000000000000000010 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 +
b00000000000000000000000000000010 -
b00000000000000000000000000000010 /
b00000000000000000000000000000010 1
b00000000000000000000000000000010 3
b00000000000000000000000000000010 5
b00000000000000000000000000000010 9
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000010 =
b00000000000000000000000000000010 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 @
b00000000000000000000000000000010 B
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000010 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 D
b00000000000000000000000000000010 F
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000010 G
b00000000000000000000000000000010 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000010 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 M
b00000000000000000000000000000010 O
b00000000000000000000000000000010 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000010 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 R
b00000000000000000000000000000010 T
b00000000000000000000000000000010 U
b00000000000000000000000000000010 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000010 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000010 Z
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#25
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#30
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
1%
b00000000000000000000000000000100 &
b00000100 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 (
b00000000000000000000000000000011 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 ,
b00000000000000000000000000000001 .
b00000000000000000000000000000001 0
b00000000000000000000000000000001 2
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 4
b00000000000000000000000000000001 6
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 7
Add lint_off -match waivers (#2102) * Add more directives to configuration files Allow to set the same directives in configuration files that can also be set by comment attributes (such as /* verilator public */ etc). * Add support for lint messsage waivers Add configuration file switch '-match' for lint_off. It takes a string with wildcards allowed and warnings will be matched against it (if rule and file also match). If it matches, the warning is waived. Fixes #1649 and #1514 Closes #2072
2020-01-12 09:03:17 +00:00
b00000000000000000000000000000001 ;
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 @
b00000000000000000000000000000011 B
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 D
b00000000000000000000000000000011 F
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 G
b00000000000000000000000000000011 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 M
b00000000000000000000000000000011 O
b00000000000000000000000000000011 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 R
b00000000000000000000000000000011 T
b00000000000000000000000000000011 U
b00000000000000000000000000000011 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 Z
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#35
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#40
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0%
b00000000000000000000000000000101 &
b00000101 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 (
b00000000000000000000000000000100 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000011 +
b00000000000000000000000000000011 -
b00000000000000000000000000000011 /
b00000000000000000000000000000011 1
b00000000000000000000000000000011 3
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000011 5
b00000000000000000000000000000001 8
b00000000000000000000000000000011 =
b00000000000000000000000000000100 ?
b00000000000000000000000000000001 A
b00000000000000000000000000000100 C
b00000000000000000000000000000001 E
b00000000000000000000000000000100 G
b00000000000000000000000000000001 I
b00000000000000000000000000000001 J
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 L
b00000000000000000000000000000001 N
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 Q
b00000000000000000000000000000001 S
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 U
b00000000000000000000000000000100 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 Y
b00000000000000000000000000000001 [
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#45
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#50
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 &
b00000110 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 (
b00000000000000000000000000000101 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 +
b00000000000000000000000000000100 -
b00000000000000000000000000000100 /
b00000000000000000000000000000100 1
b00000000000000000000000000000100 3
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 5
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000001 :
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 <
b00000000000000000000000000000101 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 @
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 B
b00000000000000000000000000000101 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 D
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 F
b00000000000000000000000000000101 G
b00000000000000000000000000000100 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 M
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 O
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000100 R
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000100 T
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 U
b00000000000000000000000000000101 V
1W
b00000000000000000000000000000001 X
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 Z
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000001 \
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#55
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#60
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 &
b00000111 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 (
b00000000000000000000000000000110 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 +
b00000000000000000000000000000101 -
b00000000000000000000000000000101 /
b00000000000000000000000000000101 1
b00000000000000000000000000000101 3
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 5
b00000000000000000000000000000011 9
b00000000000000000000000000000100 =
b00000000000000000000000000000110 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 @
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 B
b00000000000000000000000000000110 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 D
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 F
b00000000000000000000000000000110 G
b00000000000000000000000000000101 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 M
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 O
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000101 R
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000101 T
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 U
b00000000000000000000000000000110 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 Z
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#65
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#70
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 &
b00001000 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 (
b00000000000000000000000000000111 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 +
b00000000000000000000000000000110 -
b00000000000000000000000000000110 /
b00000000000000000000000000000110 1
b00000000000000000000000000000110 3
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 5
b00000000000000000000000000000100 9
b00000000000000000000000000000101 =
b00000000000000000000000000000111 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 @
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 B
b00000000000000000000000000000111 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 D
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 F
b00000000000000000000000000000111 G
b00000000000000000000000000000110 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 M
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 O
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000110 R
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000110 T
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 U
b00000000000000000000000000000111 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 Z
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#75
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#80
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 &
b00001001 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 (
b00000000000000000000000000001000 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 +
b00000000000000000000000000000111 -
b00000000000000000000000000000111 /
b00000000000000000000000000000111 1
b00000000000000000000000000000111 3
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 5
b00000000000000000000000000000101 9
b00000000000000000000000000000110 =
b00000000000000000000000000001000 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 @
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 B
b00000000000000000000000000001000 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 D
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 F
b00000000000000000000000000001000 G
b00000000000000000000000000000111 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 M
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 O
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000000111 R
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000000111 T
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 U
b00000000000000000000000000001000 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 Z
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#85
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#90
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001010 &
b00001010 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 (
b00000000000000000000000000001001 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 +
b00000000000000000000000000001000 -
b00000000000000000000000000001000 /
b00000000000000000000000000001000 1
b00000000000000000000000000001000 3
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 5
b00000000000000000000000000000110 9
b00000000000000000000000000000111 =
b00000000000000000000000000001001 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 @
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 B
b00000000000000000000000000001001 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 D
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 F
b00000000000000000000000000001001 G
b00000000000000000000000000001000 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 M
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 O
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001000 R
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001000 T
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 U
b00000000000000000000000000001001 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001010 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 Z
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#95
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
0W
Add --trace-coverage.
2019-10-27 13:27:18 +00:00
#100
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001011 &
b00001011 '
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001010 (
b00000000000000000000000000001010 *
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 +
b00000000000000000000000000001001 -
b00000000000000000000000000001001 /
b00000000000000000000000000001001 1
b00000000000000000000000000001001 3
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 5
b00000000000000000000000000000111 9
b00000000000000000000000000000001 >
b00000000000000000000000000001010 ?
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 @
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 B
b00000000000000000000000000001010 C
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 D
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 F
b00000000000000000000000000001010 G
b00000000000000000000000000001001 H
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001010 K
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001010 L
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 M
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 O
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001010 P
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001010 Q
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001001 R
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001001 T
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001010 U
b00000000000000000000000000001010 V
1W
Reduce .rodata footprint of trace initialization (#3250) Trace initialization (tracep->decl* functions) used to explicitly pass the complete hierarchical names of signals as string constants. This contains a lot of redundancy (path prefixes), does not scale well with large designs and resulted in .rodata sections (the string constants) in ELF executables being extremely large. This patch changes the API of trace initialization that allows pushing and popping name prefixes as we walk the hierarchy tree, which are prepended to declared signal names at run-time during trace initialization. This in turn allows us to emit repeat path/name components only once, effectively removing all duplicate path prefixes. On SweRV EH1 this reduces the .rodata section in a --trace build by 94%. Additionally, trace declarations are now emitted in lexical order by hierarchical signal names, and the top level trace initialization function respects --output-split-ctrace.
2021-12-19 15:15:07 +00:00
b00000000000000000000000000001011 Y
Line Coverage now tracks all statement lines, not just branch lines.
2020-05-31 19:52:17 +00:00
b00000000000000000000000000001010 Z
Reference in New Issue Copy Permalink