From 1a1d2ecfd9905df62d7521dcd3ac5ff781eb1552 Mon Sep 17 00:00:00 2001 From: Krzysztof Bieganski Date: Thu, 25 Aug 2022 15:55:37 +0200 Subject: [PATCH 1/9] Enable tracing in generated main (#3578) Signed-off-by: Krzysztof Bieganski --- src/V3EmitCMain.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/V3EmitCMain.cpp b/src/V3EmitCMain.cpp index c717b7751..be04510aa 100644 --- a/src/V3EmitCMain.cpp +++ b/src/V3EmitCMain.cpp @@ -62,6 +62,7 @@ private: puts("int main(int argc, char** argv, char**) {\n"); puts("// Setup context, defaults, and parse command line\n"); puts("Verilated::debug(0);\n"); + if (v3Global.opt.trace()) puts("Verilated::traceEverOn(true);\n"); puts("const std::unique_ptr contextp{new VerilatedContext};\n"); puts("contextp->commandArgs(argc, argv);\n"); puts("\n"); From 5869fdf7f6f43103c5a7d09b9d0a4f21774bcb29 Mon Sep 17 00:00:00 2001 From: Varun Koyyalagunta Date: Thu, 25 Aug 2022 18:29:11 -0500 Subject: [PATCH 2/9] Fix $dump systemtask with --output-split-cfuncs (#3495) (#3497) --- docs/CONTRIBUTORS | 1 + src/V3EmitCSyms.cpp | 57 ++++++++++--------- test_regress/t/t_trace_split_cfuncs.pl | 18 ++++++ test_regress/t/t_trace_split_cfuncs.v | 14 +++++ .../t/t_trace_split_cfuncs_dpi_export.pl | 18 ++++++ .../t/t_trace_split_cfuncs_dpi_export.v | 18 ++++++ 6 files changed, 98 insertions(+), 28 deletions(-) create mode 100755 test_regress/t/t_trace_split_cfuncs.pl create mode 100644 test_regress/t/t_trace_split_cfuncs.v create mode 100755 test_regress/t/t_trace_split_cfuncs_dpi_export.pl create mode 100644 test_regress/t/t_trace_split_cfuncs_dpi_export.v diff --git a/docs/CONTRIBUTORS b/docs/CONTRIBUTORS index 228787d5e..e16c20cb2 100644 --- a/docs/CONTRIBUTORS +++ b/docs/CONTRIBUTORS @@ -116,6 +116,7 @@ Tomasz Gorochowik Tymoteusz Blazejczyk Udi Finkelstein Unai Martinez-Corral +Varun Koyyalagunta Vassilis Papaefstathiou Veripool API Bot Victor Besyakov diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp index de8be89b6..5193bd7e6 100644 --- a/src/V3EmitCSyms.cpp +++ b/src/V3EmitCSyms.cpp @@ -673,7 +673,35 @@ void EmitCSyms::emitSymImp() { puts("_vm_pgoProfiler.write(\"" + topClassName() + "\", _vm_contextp__->profVltFilename());\n"); } - puts("}\n\n"); + puts("}\n"); + + if (v3Global.needTraceDumper()) { + if (!optSystemC()) { + puts("\nvoid " + symClassName() + "::_traceDump() {\n"); + // Caller checked for __Vm_dumperp non-nullptr + puts("const VerilatedLockGuard lock(__Vm_dumperMutex);\n"); + puts("__Vm_dumperp->dump(VL_TIME_Q());\n"); + puts("}\n"); + } + + puts("\nvoid " + symClassName() + "::_traceDumpOpen() {\n"); + puts("const VerilatedLockGuard lock(__Vm_dumperMutex);\n"); + puts("if (VL_UNLIKELY(!__Vm_dumperp)) {\n"); + puts("__Vm_dumperp = new " + v3Global.opt.traceClassLang() + "();\n"); + puts("__Vm_modelp->trace(__Vm_dumperp, 0, 0);\n"); + puts("std::string dumpfile = _vm_contextp__->dumpfileCheck();\n"); + puts("__Vm_dumperp->open(dumpfile.c_str());\n"); + puts("__Vm_dumping = true;\n"); + puts("}\n"); + puts("}\n"); + + puts("\nvoid " + symClassName() + "::_traceDumpClose() {\n"); + puts("const VerilatedLockGuard lock(__Vm_dumperMutex);\n"); + puts("__Vm_dumping = false;\n"); + puts("VL_DO_CLEAR(delete __Vm_dumperp, __Vm_dumperp = nullptr);\n"); + puts("}\n"); + } + puts("\n"); // Constructor puts(symClassName() + "::" + symClassName() @@ -923,33 +951,6 @@ void EmitCSyms::emitSymImp() { m_ofpBase->puts("}\n"); - if (v3Global.needTraceDumper()) { - if (!optSystemC()) { - puts("\nvoid " + symClassName() + "::_traceDump() {\n"); - // Caller checked for __Vm_dumperp non-nullptr - puts("const VerilatedLockGuard lock(__Vm_dumperMutex);\n"); - puts("__Vm_dumperp->dump(VL_TIME_Q());\n"); - puts("}\n"); - } - - puts("\nvoid " + symClassName() + "::_traceDumpOpen() {\n"); - puts("const VerilatedLockGuard lock(__Vm_dumperMutex);\n"); - puts("if (VL_UNLIKELY(!__Vm_dumperp)) {\n"); - puts("__Vm_dumperp = new " + v3Global.opt.traceClassLang() + "();\n"); - puts("__Vm_modelp->trace(__Vm_dumperp, 0, 0);\n"); - puts("std::string dumpfile = _vm_contextp__->dumpfileCheck();\n"); - puts("__Vm_dumperp->open(dumpfile.c_str());\n"); - puts("__Vm_dumping = true;\n"); - puts("}\n"); - puts("}\n"); - - puts("\nvoid " + symClassName() + "::_traceDumpClose() {\n"); - puts("const VerilatedLockGuard lock(__Vm_dumperMutex);\n"); - puts("__Vm_dumping = false;\n"); - puts("VL_DO_CLEAR(delete __Vm_dumperp, __Vm_dumperp = nullptr);\n"); - puts("}\n"); - } - closeSplit(); m_ofp = nullptr; VL_DO_CLEAR(delete m_ofpBase, m_ofpBase = nullptr); diff --git a/test_regress/t/t_trace_split_cfuncs.pl b/test_regress/t/t_trace_split_cfuncs.pl new file mode 100755 index 000000000..4959ee710 --- /dev/null +++ b/test_regress/t/t_trace_split_cfuncs.pl @@ -0,0 +1,18 @@ +#!/usr/bin/env perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2003 by Wilson Snyder. This program is free software; you +# can redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +scenarios(simulator => 1); + +compile( + v_flags2 => ["--trace", "--output-split-cfuncs", "1"] + ); + +ok(1); +1; diff --git a/test_regress/t/t_trace_split_cfuncs.v b/test_regress/t/t_trace_split_cfuncs.v new file mode 100644 index 000000000..cf364ad5a --- /dev/null +++ b/test_regress/t/t_trace_split_cfuncs.v @@ -0,0 +1,14 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed under the Creative Commons Public Domain, for +// any use, without warranty, 2022 by Varun Koyyalagunta. +// SPDX-License-Identifier: CC0-1.0 + +module t (); + + initial begin + $dumpfile("dump.vcd"); + $dumpvars(); + end + +endmodule diff --git a/test_regress/t/t_trace_split_cfuncs_dpi_export.pl b/test_regress/t/t_trace_split_cfuncs_dpi_export.pl new file mode 100755 index 000000000..4959ee710 --- /dev/null +++ b/test_regress/t/t_trace_split_cfuncs_dpi_export.pl @@ -0,0 +1,18 @@ +#!/usr/bin/env perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2003 by Wilson Snyder. This program is free software; you +# can redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +scenarios(simulator => 1); + +compile( + v_flags2 => ["--trace", "--output-split-cfuncs", "1"] + ); + +ok(1); +1; diff --git a/test_regress/t/t_trace_split_cfuncs_dpi_export.v b/test_regress/t/t_trace_split_cfuncs_dpi_export.v new file mode 100644 index 000000000..cec80cc3c --- /dev/null +++ b/test_regress/t/t_trace_split_cfuncs_dpi_export.v @@ -0,0 +1,18 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed under the Creative Commons Public Domain, for +// any use, without warranty, 2022 by Varun Koyyalagunta. +// SPDX-License-Identifier: CC0-1.0 + +module t (); + + function automatic void func(); + endfunction + export "DPI-C" function func; + + initial begin + $dumpfile("dump.vcd"); + $dumpvars(); + end + +endmodule From 2358ced0611c85debaeb73d36dde629a0d77ab76 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Sun, 28 Aug 2022 08:25:02 -0400 Subject: [PATCH 3/9] Rename tracing rolloverSize and add test (#3570). --- Changes | 1 + include/verilated_vcd_c.cpp | 6 +- include/verilated_vcd_c.h | 14 +- test_regress/t/t_trace_rollover.cpp | 45 + test_regress/t/t_trace_rollover.out | 4765 +++++++++++++++++++++++++++ test_regress/t/t_trace_rollover.pl | 36 + 6 files changed, 4859 insertions(+), 8 deletions(-) create mode 100644 test_regress/t/t_trace_rollover.cpp create mode 100644 test_regress/t/t_trace_rollover.out create mode 100755 test_regress/t/t_trace_rollover.pl diff --git a/Changes b/Changes index ff4509bcc..3dd9088a4 100644 --- a/Changes +++ b/Changes @@ -22,6 +22,7 @@ Verilator 4.225 devel * Fix segfault exporting non-existant package (#3535). * Fix case statement comparing string literal (#3544). [Gustav Svensk] * Improve Verilation speed with --threads on large designs. [Geza Lore] +* Rename trace rolloverSize() (#3570). Verilator 4.224 2022-06-19 diff --git a/include/verilated_vcd_c.cpp b/include/verilated_vcd_c.cpp index 9681e1883..ed36e6583 100644 --- a/include/verilated_vcd_c.cpp +++ b/include/verilated_vcd_c.cpp @@ -120,13 +120,13 @@ void VerilatedVcd::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) { // Set member variables m_filename = filename; // "" is ok, as someone may overload open - openNextImp(m_rolloverMB != 0); + openNextImp(m_rolloverSize != 0); if (!isOpen()) return; dumpHeader(); // When using rollover, the first chunk contains the header only. - if (m_rolloverMB) openNextImp(true); + if (m_rolloverSize) openNextImp(true); } void VerilatedVcd::openNext(bool incFilename) VL_MT_SAFE_EXCLUDES(m_mutex) { @@ -180,7 +180,7 @@ void VerilatedVcd::openNextImp(bool incFilename) { } bool VerilatedVcd::preChangeDump() { - if (VL_UNLIKELY(m_rolloverMB && m_wroteBytes > m_rolloverMB)) openNextImp(true); + if (VL_UNLIKELY(m_rolloverSize && m_wroteBytes > m_rolloverSize)) openNextImp(true); return isOpen(); } diff --git a/include/verilated_vcd_c.h b/include/verilated_vcd_c.h index 153401b29..9079ef926 100644 --- a/include/verilated_vcd_c.h +++ b/include/verilated_vcd_c.h @@ -50,7 +50,7 @@ private: bool m_fileNewed; // m_filep needs destruction bool m_isOpen = false; // True indicates open file std::string m_filename; // Filename we're writing to (if open) - uint64_t m_rolloverMB = 0; // MB of file size to rollover at + uint64_t m_rolloverSize = 0; // File size to rollover at int m_modDepth = 0; // Depth of module hierarchy char* m_wrBufp; // Output buffer @@ -124,8 +124,8 @@ public: ~VerilatedVcd(); // ACCESSORS - // Set size in megabytes after which new file should be created - void rolloverMB(uint64_t rolloverMB) { m_rolloverMB = rolloverMB; } + // Set size in bytes after which new file should be created. + void rolloverSize(uint64_t size) { m_rolloverSize = size; } // METHODS - All must be thread safe // Open the file; call isOpen() to see if errors @@ -271,8 +271,12 @@ public: /// The header is only in the first file created, this allows /// "cat" to be used to combine the header plus any number of data files. void openNext(bool incFilename = true) VL_MT_SAFE { m_sptrace.openNext(incFilename); } - /// Set size in megabytes after which new file should be created - void rolloverMB(size_t rolloverMB) VL_MT_SAFE { m_sptrace.rolloverMB(rolloverMB); } + /// Set size in bytes after which new file should be created + /// This will create a header file, followed by each separate file + /// which might be larger than the given size (due to chunking and + /// alignment to a start of a given time's dump). Any file but the + /// first may be removed. Cat files together to create viewable vcd. + void rolloverSize(size_t size) VL_MT_SAFE { m_sptrace.rolloverSize(size); } /// Close dump void close() VL_MT_SAFE { m_sptrace.close(); } /// Flush dump diff --git a/test_regress/t/t_trace_rollover.cpp b/test_regress/t/t_trace_rollover.cpp new file mode 100644 index 000000000..f2331b124 --- /dev/null +++ b/test_regress/t/t_trace_rollover.cpp @@ -0,0 +1,45 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +// +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed under the Creative Commons Public Domain, for +// any use, without warranty, 2008 by Wilson Snyder. +// SPDX-License-Identifier: CC0-1.0 + +#include +#include + +#include + +#include VM_PREFIX_INCLUDE + +unsigned long long main_time = 0; +double sc_time_stamp() { return (double)main_time; } + +int main(int argc, char** argv, char** env) { + std::unique_ptr top{new VM_PREFIX("top")}; + + Verilated::debug(0); + Verilated::traceEverOn(true); + + std::unique_ptr tfp{new VerilatedVcdC}; + top->trace(tfp.get(), 99); + + tfp->rolloverSize(1000); // But will be increased to 8kb chunk size + tfp->open(VL_STRINGIFY(TEST_OBJ_DIR) "/simrollover.vcd"); + + top->clk = 0; + + while (main_time < 1900) { // Creates 2 files + top->clk = !top->clk; + top->eval(); + tfp->dump((unsigned int)(main_time)); + ++main_time; + } + tfp->close(); + top->final(); + tfp.reset(); + top.reset(); + printf("*-* All Finished *-*\n"); + return 0; +} diff --git a/test_regress/t/t_trace_rollover.out b/test_regress/t/t_trace_rollover.out new file mode 100644 index 000000000..155fedd1b --- /dev/null +++ b/test_regress/t/t_trace_rollover.out @@ -0,0 +1,4765 @@ +$version Generated by VerilatedVcd $end +$date Sun Aug 28 08:18:01 2022 $end +$timescale 1ps $end + + $scope module top $end + $var wire 1 # clk $end + $scope module t $end + $var wire 1 # clk $end + $var wire 32 $ cyc [31:0] $end + $upscope $end + $upscope $end +$enddefinitions $end + + +#0 +1# +b00000000000000000000000000000000 $ +#1 +0# +#2 +1# +b00000000000000000000000000000001 $ +#3 +0# +#4 +1# +b00000000000000000000000000000010 $ +#5 +0# +#6 +1# +b00000000000000000000000000000011 $ +#7 +0# +#8 +1# +b00000000000000000000000000000100 $ +#9 +0# +#10 +1# +b00000000000000000000000000000101 $ +#11 +0# +#12 +1# +b00000000000000000000000000000110 $ +#13 +0# +#14 +1# +b00000000000000000000000000000111 $ +#15 +0# +#16 +1# +b00000000000000000000000000001000 $ +#17 +0# +#18 +1# +b00000000000000000000000000001001 $ +#19 +0# +#20 +1# +b00000000000000000000000000001010 $ +#21 +0# +#22 +1# +b00000000000000000000000000001011 $ +#23 +0# +#24 +1# +b00000000000000000000000000001100 $ +#25 +0# +#26 +1# +b00000000000000000000000000001101 $ +#27 +0# +#28 +1# +b00000000000000000000000000001110 $ +#29 +0# +#30 +1# +b00000000000000000000000000001111 $ +#31 +0# +#32 +1# +b00000000000000000000000000010000 $ +#33 +0# +#34 +1# +b00000000000000000000000000010001 $ +#35 +0# +#36 +1# +b00000000000000000000000000010010 $ +#37 +0# +#38 +1# +b00000000000000000000000000010011 $ +#39 +0# +#40 +1# +b00000000000000000000000000010100 $ +#41 +0# +#42 +1# +b00000000000000000000000000010101 $ +#43 +0# +#44 +1# +b00000000000000000000000000010110 $ +#45 +0# +#46 +1# +b00000000000000000000000000010111 $ +#47 +0# +#48 +1# +b00000000000000000000000000011000 $ +#49 +0# +#50 +1# +b00000000000000000000000000011001 $ +#51 +0# +#52 +1# +b00000000000000000000000000011010 $ +#53 +0# +#54 +1# +b00000000000000000000000000011011 $ +#55 +0# +#56 +1# +b00000000000000000000000000011100 $ +#57 +0# +#58 +1# +b00000000000000000000000000011101 $ +#59 +0# +#60 +1# +b00000000000000000000000000011110 $ +#61 +0# +#62 +1# +b00000000000000000000000000011111 $ +#63 +0# +#64 +1# +b00000000000000000000000000100000 $ +#65 +0# +#66 +1# +b00000000000000000000000000100001 $ +#67 +0# +#68 +1# +b00000000000000000000000000100010 $ +#69 +0# +#70 +1# +b00000000000000000000000000100011 $ +#71 +0# +#72 +1# +b00000000000000000000000000100100 $ +#73 +0# +#74 +1# +b00000000000000000000000000100101 $ +#75 +0# +#76 +1# +b00000000000000000000000000100110 $ +#77 +0# +#78 +1# +b00000000000000000000000000100111 $ +#79 +0# +#80 +1# +b00000000000000000000000000101000 $ +#81 +0# +#82 +1# +b00000000000000000000000000101001 $ +#83 +0# +#84 +1# +b00000000000000000000000000101010 $ +#85 +0# +#86 +1# +b00000000000000000000000000101011 $ +#87 +0# +#88 +1# +b00000000000000000000000000101100 $ +#89 +0# +#90 +1# +b00000000000000000000000000101101 $ +#91 +0# +#92 +1# +b00000000000000000000000000101110 $ +#93 +0# +#94 +1# +b00000000000000000000000000101111 $ +#95 +0# +#96 +1# +b00000000000000000000000000110000 $ +#97 +0# +#98 +1# +b00000000000000000000000000110001 $ +#99 +0# +#100 +1# +b00000000000000000000000000110010 $ +#101 +0# +#102 +1# +b00000000000000000000000000110011 $ +#103 +0# +#104 +1# +b00000000000000000000000000110100 $ +#105 +0# +#106 +1# +b00000000000000000000000000110101 $ +#107 +0# +#108 +1# +b00000000000000000000000000110110 $ +#109 +0# +#110 +1# +b00000000000000000000000000110111 $ +#111 +0# +#112 +1# +b00000000000000000000000000111000 $ +#113 +0# +#114 +1# +b00000000000000000000000000111001 $ +#115 +0# +#116 +1# +b00000000000000000000000000111010 $ +#117 +0# +#118 +1# +b00000000000000000000000000111011 $ +#119 +0# +#120 +1# +b00000000000000000000000000111100 $ +#121 +0# +#122 +1# +b00000000000000000000000000111101 $ +#123 +0# +#124 +1# +b00000000000000000000000000111110 $ +#125 +0# +#126 +1# +b00000000000000000000000000111111 $ +#127 +0# +#128 +1# +b00000000000000000000000001000000 $ +#129 +0# +#130 +1# +b00000000000000000000000001000001 $ +#131 +0# +#132 +1# +b00000000000000000000000001000010 $ +#133 +0# +#134 +1# +b00000000000000000000000001000011 $ +#135 +0# +#136 +1# +b00000000000000000000000001000100 $ +#137 +0# +#138 +1# +b00000000000000000000000001000101 $ +#139 +0# +#140 +1# +b00000000000000000000000001000110 $ +#141 +0# +#142 +1# +b00000000000000000000000001000111 $ +#143 +0# +#144 +1# +b00000000000000000000000001001000 $ +#145 +0# +#146 +1# +b00000000000000000000000001001001 $ +#147 +0# +#148 +1# +b00000000000000000000000001001010 $ +#149 +0# +#150 +1# +b00000000000000000000000001001011 $ +#151 +0# +#152 +1# +b00000000000000000000000001001100 $ +#153 +0# +#154 +1# +b00000000000000000000000001001101 $ +#155 +0# +#156 +1# +b00000000000000000000000001001110 $ +#157 +0# +#158 +1# +b00000000000000000000000001001111 $ +#159 +0# +#160 +1# +b00000000000000000000000001010000 $ +#161 +0# +#162 +1# +b00000000000000000000000001010001 $ +#163 +0# +#164 +1# +b00000000000000000000000001010010 $ +#165 +0# +#166 +1# +b00000000000000000000000001010011 $ +#167 +0# +#168 +1# +b00000000000000000000000001010100 $ +#169 +0# +#170 +1# +b00000000000000000000000001010101 $ +#171 +0# +#172 +1# +b00000000000000000000000001010110 $ +#173 +0# +#174 +1# +b00000000000000000000000001010111 $ +#175 +0# +#176 +1# +b00000000000000000000000001011000 $ +#177 +0# +#178 +1# +b00000000000000000000000001011001 $ +#179 +0# +#180 +1# +b00000000000000000000000001011010 $ +#181 +0# +#182 +1# +b00000000000000000000000001011011 $ +#183 +0# +#184 +1# +b00000000000000000000000001011100 $ +#185 +0# +#186 +1# +b00000000000000000000000001011101 $ +#187 +0# +#188 +1# +b00000000000000000000000001011110 $ +#189 +0# +#190 +1# +b00000000000000000000000001011111 $ +#191 +0# +#192 +1# +b00000000000000000000000001100000 $ +#193 +0# +#194 +1# +b00000000000000000000000001100001 $ +#195 +0# +#196 +1# +b00000000000000000000000001100010 $ +#197 +0# +#198 +1# +b00000000000000000000000001100011 $ +#199 +0# +#200 +1# +b00000000000000000000000001100100 $ +#201 +0# +#202 +1# +b00000000000000000000000001100101 $ +#203 +0# +#204 +1# +b00000000000000000000000001100110 $ +#205 +0# +#206 +1# +b00000000000000000000000001100111 $ +#207 +0# +#208 +1# +b00000000000000000000000001101000 $ +#209 +0# +#210 +1# +b00000000000000000000000001101001 $ +#211 +0# +#212 +1# +b00000000000000000000000001101010 $ +#213 +0# +#214 +1# +b00000000000000000000000001101011 $ +#215 +0# +#216 +1# +b00000000000000000000000001101100 $ +#217 +0# +#218 +1# +b00000000000000000000000001101101 $ +#219 +0# +#220 +1# +b00000000000000000000000001101110 $ +#221 +0# +#222 +1# +b00000000000000000000000001101111 $ +#223 +0# +#224 +1# +b00000000000000000000000001110000 $ +#225 +0# +#226 +1# +b00000000000000000000000001110001 $ +#227 +0# +#228 +1# +b00000000000000000000000001110010 $ +#229 +0# +#230 +1# +b00000000000000000000000001110011 $ +#231 +0# +#232 +1# +b00000000000000000000000001110100 $ +#233 +0# +#234 +1# +b00000000000000000000000001110101 $ +#235 +0# +#236 +1# +b00000000000000000000000001110110 $ +#237 +0# +#238 +1# +b00000000000000000000000001110111 $ +#239 +0# +#240 +1# +b00000000000000000000000001111000 $ +#241 +0# +#242 +1# +b00000000000000000000000001111001 $ +#243 +0# +#244 +1# +b00000000000000000000000001111010 $ +#245 +0# +#246 +1# +b00000000000000000000000001111011 $ +#247 +0# +#248 +1# +b00000000000000000000000001111100 $ +#249 +0# +#250 +1# +b00000000000000000000000001111101 $ +#251 +0# +#252 +1# +b00000000000000000000000001111110 $ +#253 +0# +#254 +1# +b00000000000000000000000001111111 $ +#255 +0# +#256 +1# +b00000000000000000000000010000000 $ +#257 +0# +#258 +1# +b00000000000000000000000010000001 $ +#259 +0# +#260 +1# +b00000000000000000000000010000010 $ +#261 +0# +#262 +1# +b00000000000000000000000010000011 $ +#263 +0# +#264 +1# +b00000000000000000000000010000100 $ +#265 +0# +#266 +1# +b00000000000000000000000010000101 $ +#267 +0# +#268 +1# +b00000000000000000000000010000110 $ +#269 +0# +#270 +1# +b00000000000000000000000010000111 $ +#271 +0# +#272 +1# +b00000000000000000000000010001000 $ +#273 +0# +#274 +1# +b00000000000000000000000010001001 $ +#275 +0# +#276 +1# +b00000000000000000000000010001010 $ +#277 +0# +#278 +1# +b00000000000000000000000010001011 $ +#279 +0# +#280 +1# +b00000000000000000000000010001100 $ +#281 +0# +#282 +1# +b00000000000000000000000010001101 $ +#283 +0# +#284 +1# +b00000000000000000000000010001110 $ +#285 +0# +#286 +1# +b00000000000000000000000010001111 $ +#287 +0# +#288 +1# +b00000000000000000000000010010000 $ +#289 +0# +#290 +1# +b00000000000000000000000010010001 $ +#291 +0# +#292 +1# +b00000000000000000000000010010010 $ +#293 +0# +#294 +1# +b00000000000000000000000010010011 $ +#295 +0# +#296 +1# +b00000000000000000000000010010100 $ +#297 +0# +#298 +1# +b00000000000000000000000010010101 $ +#299 +0# +#300 +1# +b00000000000000000000000010010110 $ +#301 +0# +#302 +1# +b00000000000000000000000010010111 $ +#303 +0# +#304 +1# +b00000000000000000000000010011000 $ +#305 +0# +#306 +1# +b00000000000000000000000010011001 $ +#307 +0# +#308 +1# +b00000000000000000000000010011010 $ +#309 +0# +#310 +1# +b00000000000000000000000010011011 $ +#311 +0# +#312 +1# +b00000000000000000000000010011100 $ +#313 +0# +#314 +1# +b00000000000000000000000010011101 $ +#315 +0# +#316 +1# +b00000000000000000000000010011110 $ +#317 +0# +#318 +1# +b00000000000000000000000010011111 $ +#319 +0# +#320 +1# +b00000000000000000000000010100000 $ +#321 +0# +#322 +1# +b00000000000000000000000010100001 $ +#323 +0# +#324 +1# +b00000000000000000000000010100010 $ +#325 +0# +#326 +1# +b00000000000000000000000010100011 $ +#327 +0# +#328 +1# +b00000000000000000000000010100100 $ +#329 +0# +#330 +1# +b00000000000000000000000010100101 $ +#331 +0# +#332 +1# +b00000000000000000000000010100110 $ +#333 +0# +#334 +1# +b00000000000000000000000010100111 $ +#335 +0# +#336 +1# +b00000000000000000000000010101000 $ +#337 +0# +#338 +1# +b00000000000000000000000010101001 $ +#339 +0# +#340 +1# +b00000000000000000000000010101010 $ +#341 +0# +#342 +1# +b00000000000000000000000010101011 $ +#343 +0# +#344 +1# +b00000000000000000000000010101100 $ +#345 +0# +#346 +1# +b00000000000000000000000010101101 $ +#347 +0# +#348 +1# +b00000000000000000000000010101110 $ +#349 +0# +#350 +1# +b00000000000000000000000010101111 $ +#351 +0# +#352 +1# +b00000000000000000000000010110000 $ +#353 +0# +#354 +1# +b00000000000000000000000010110001 $ +#355 +0# +#356 +1# +b00000000000000000000000010110010 $ +#357 +0# +#358 +1# +b00000000000000000000000010110011 $ +#359 +0# +#360 +1# +b00000000000000000000000010110100 $ +#361 +0# +#362 +1# +b00000000000000000000000010110101 $ +#363 +0# +#364 +1# +b00000000000000000000000010110110 $ +#365 +0# +#366 +1# +b00000000000000000000000010110111 $ +#367 +0# +#368 +1# +b00000000000000000000000010111000 $ +#369 +0# +#370 +1# +b00000000000000000000000010111001 $ +#371 +0# +#372 +1# +b00000000000000000000000010111010 $ +#373 +0# +#374 +1# +b00000000000000000000000010111011 $ +#375 +0# +#376 +1# +b00000000000000000000000010111100 $ +#377 +0# +#378 +1# +b00000000000000000000000010111101 $ +#379 +0# +#380 +1# +b00000000000000000000000010111110 $ +#381 +0# +#382 +1# +b00000000000000000000000010111111 $ +#383 +0# +#384 +1# +b00000000000000000000000011000000 $ +#385 +0# +#386 +1# +b00000000000000000000000011000001 $ +#387 +0# +#388 +1# +b00000000000000000000000011000010 $ +#389 +0# +#390 +1# +b00000000000000000000000011000011 $ +#391 +0# +#392 +1# +b00000000000000000000000011000100 $ +#393 +0# +#394 +1# +b00000000000000000000000011000101 $ +#395 +0# +#396 +1# +b00000000000000000000000011000110 $ +#397 +0# +#398 +1# +b00000000000000000000000011000111 $ +#399 +0# +#400 +1# +b00000000000000000000000011001000 $ +#401 +0# +#402 +1# +b00000000000000000000000011001001 $ +#403 +0# +#404 +1# +b00000000000000000000000011001010 $ +#405 +0# +#406 +1# +b00000000000000000000000011001011 $ +#407 +0# +#408 +1# +b00000000000000000000000011001100 $ +#409 +0# +#410 +1# +b00000000000000000000000011001101 $ +#411 +0# +#412 +1# +b00000000000000000000000011001110 $ +#413 +0# +#414 +1# +b00000000000000000000000011001111 $ +#415 +0# +#416 +1# +b00000000000000000000000011010000 $ +#417 +0# +#418 +1# +b00000000000000000000000011010001 $ +#419 +0# +#420 +1# +b00000000000000000000000011010010 $ +#421 +0# +#422 +1# +b00000000000000000000000011010011 $ +#423 +0# +#424 +1# +b00000000000000000000000011010100 $ +#425 +0# +#426 +1# +b00000000000000000000000011010101 $ +#427 +0# +#428 +1# +b00000000000000000000000011010110 $ +#429 +0# +#430 +1# +b00000000000000000000000011010111 $ +#431 +0# +#432 +1# +b00000000000000000000000011011000 $ +#433 +0# +#434 +1# +b00000000000000000000000011011001 $ +#435 +0# +#436 +1# +b00000000000000000000000011011010 $ +#437 +0# +#438 +1# +b00000000000000000000000011011011 $ +#439 +0# +#440 +1# +b00000000000000000000000011011100 $ +#441 +0# +#442 +1# +b00000000000000000000000011011101 $ +#443 +0# +#444 +1# +b00000000000000000000000011011110 $ +#445 +0# +#446 +1# +b00000000000000000000000011011111 $ +#447 +0# +#448 +1# +b00000000000000000000000011100000 $ +#449 +0# +#450 +1# +b00000000000000000000000011100001 $ +#451 +0# +#452 +1# +b00000000000000000000000011100010 $ +#453 +0# +#454 +1# +b00000000000000000000000011100011 $ +#455 +0# +#456 +1# +b00000000000000000000000011100100 $ +#457 +0# +#458 +1# +b00000000000000000000000011100101 $ +#459 +0# +#460 +1# +b00000000000000000000000011100110 $ +#461 +0# +#462 +1# +b00000000000000000000000011100111 $ +#463 +0# +#464 +1# +b00000000000000000000000011101000 $ +#465 +0# +#466 +1# +b00000000000000000000000011101001 $ +#467 +0# +#468 +1# +b00000000000000000000000011101010 $ +#469 +0# +#470 +1# +b00000000000000000000000011101011 $ +#471 +0# +#472 +1# +b00000000000000000000000011101100 $ +#473 +0# +#474 +1# +b00000000000000000000000011101101 $ +#475 +0# +#476 +1# +b00000000000000000000000011101110 $ +#477 +0# +#478 +1# +b00000000000000000000000011101111 $ +#479 +0# +#480 +1# +b00000000000000000000000011110000 $ +#481 +0# +#482 +1# +b00000000000000000000000011110001 $ +#483 +0# +#484 +1# +b00000000000000000000000011110010 $ +#485 +0# +#486 +1# +b00000000000000000000000011110011 $ +#487 +0# +#488 +1# +b00000000000000000000000011110100 $ +#489 +0# +#490 +1# +b00000000000000000000000011110101 $ +#491 +0# +#492 +1# +b00000000000000000000000011110110 $ +#493 +0# +#494 +1# +b00000000000000000000000011110111 $ +#495 +0# +#496 +1# +b00000000000000000000000011111000 $ +#497 +0# +#498 +1# +b00000000000000000000000011111001 $ +#499 +0# +#500 +1# +b00000000000000000000000011111010 $ +#501 +0# +#502 +1# +b00000000000000000000000011111011 $ +#503 +0# +#504 +1# +b00000000000000000000000011111100 $ +#505 +0# +#506 +1# +b00000000000000000000000011111101 $ +#507 +0# +#508 +1# +b00000000000000000000000011111110 $ +#509 +0# +#510 +1# +b00000000000000000000000011111111 $ +#511 +0# +#512 +1# +b00000000000000000000000100000000 $ +#513 +0# +#514 +1# +b00000000000000000000000100000001 $ +#515 +0# +#516 +1# +b00000000000000000000000100000010 $ +#517 +0# +#518 +1# +b00000000000000000000000100000011 $ +#519 +0# +#520 +1# +b00000000000000000000000100000100 $ +#521 +0# +#522 +1# +b00000000000000000000000100000101 $ +#523 +0# +#524 +1# +b00000000000000000000000100000110 $ +#525 +0# +#526 +1# +b00000000000000000000000100000111 $ +#527 +0# +#528 +1# +b00000000000000000000000100001000 $ +#529 +0# +#530 +1# +b00000000000000000000000100001001 $ +#531 +0# +#532 +1# +b00000000000000000000000100001010 $ +#533 +0# +#534 +1# +b00000000000000000000000100001011 $ +#535 +0# +#536 +1# +b00000000000000000000000100001100 $ +#537 +0# +#538 +1# +b00000000000000000000000100001101 $ +#539 +0# +#540 +1# +b00000000000000000000000100001110 $ +#541 +0# +#542 +1# +b00000000000000000000000100001111 $ +#543 +0# +#544 +1# +b00000000000000000000000100010000 $ +#545 +0# +#546 +1# +b00000000000000000000000100010001 $ +#547 +0# +#548 +1# +b00000000000000000000000100010010 $ +#549 +0# +#550 +1# +b00000000000000000000000100010011 $ +#551 +0# +#552 +1# +b00000000000000000000000100010100 $ +#553 +0# +#554 +1# +b00000000000000000000000100010101 $ +#555 +0# +#556 +1# +b00000000000000000000000100010110 $ +#557 +0# +#558 +1# +b00000000000000000000000100010111 $ +#559 +0# +#560 +1# +b00000000000000000000000100011000 $ +#561 +0# +#562 +1# +b00000000000000000000000100011001 $ +#563 +0# +#564 +1# +b00000000000000000000000100011010 $ +#565 +0# +#566 +1# +b00000000000000000000000100011011 $ +#567 +0# +#568 +1# +b00000000000000000000000100011100 $ +#569 +0# +#570 +1# +b00000000000000000000000100011101 $ +#571 +0# +#572 +1# +b00000000000000000000000100011110 $ +#573 +0# +#574 +1# +b00000000000000000000000100011111 $ +#575 +0# +#576 +1# +b00000000000000000000000100100000 $ +#577 +0# +#578 +1# +b00000000000000000000000100100001 $ +#579 +0# +#580 +1# +b00000000000000000000000100100010 $ +#581 +0# +#582 +1# +b00000000000000000000000100100011 $ +#583 +0# +#584 +1# +b00000000000000000000000100100100 $ +#585 +0# +#586 +1# +b00000000000000000000000100100101 $ +#587 +0# +#588 +1# +b00000000000000000000000100100110 $ +#589 +0# +#590 +1# +b00000000000000000000000100100111 $ +#591 +0# +#592 +1# +b00000000000000000000000100101000 $ +#593 +0# +#594 +1# +b00000000000000000000000100101001 $ +#595 +0# +#596 +1# +b00000000000000000000000100101010 $ +#597 +0# +#598 +1# +b00000000000000000000000100101011 $ +#599 +0# +#600 +1# +b00000000000000000000000100101100 $ +#601 +0# +#602 +1# +b00000000000000000000000100101101 $ +#603 +0# +#604 +1# +b00000000000000000000000100101110 $ +#605 +0# +#606 +1# +b00000000000000000000000100101111 $ +#607 +0# +#608 +1# +b00000000000000000000000100110000 $ +#609 +0# +#610 +1# +b00000000000000000000000100110001 $ +#611 +0# +#612 +1# +b00000000000000000000000100110010 $ +#613 +0# +#614 +1# +b00000000000000000000000100110011 $ +#615 +0# +#616 +1# +b00000000000000000000000100110100 $ +#617 +0# +#618 +1# +b00000000000000000000000100110101 $ +#619 +0# +#620 +1# +b00000000000000000000000100110110 $ +#621 +0# +#622 +1# +b00000000000000000000000100110111 $ +#623 +0# +#624 +1# +b00000000000000000000000100111000 $ +#625 +0# +#626 +1# +b00000000000000000000000100111001 $ +#627 +0# +#628 +1# +b00000000000000000000000100111010 $ +#629 +0# +#630 +1# +b00000000000000000000000100111011 $ +#631 +0# +#632 +1# +b00000000000000000000000100111100 $ +#633 +0# +#634 +1# +b00000000000000000000000100111101 $ +#635 +0# +#636 +1# +b00000000000000000000000100111110 $ +#637 +0# +#638 +1# +b00000000000000000000000100111111 $ +#639 +0# +#640 +1# +b00000000000000000000000101000000 $ +#641 +0# +#642 +1# +b00000000000000000000000101000001 $ +#643 +0# +#644 +1# +b00000000000000000000000101000010 $ +#645 +0# +#646 +1# +b00000000000000000000000101000011 $ +#647 +0# +#648 +1# +b00000000000000000000000101000100 $ +#649 +0# +#650 +1# +b00000000000000000000000101000101 $ +#651 +0# +#652 +1# +b00000000000000000000000101000110 $ +#653 +0# +#654 +1# +b00000000000000000000000101000111 $ +#655 +0# +#656 +1# +b00000000000000000000000101001000 $ +#657 +0# +#658 +1# +b00000000000000000000000101001001 $ +#659 +0# +#660 +1# +b00000000000000000000000101001010 $ +#661 +0# +#662 +1# +b00000000000000000000000101001011 $ +#663 +0# +#664 +1# +b00000000000000000000000101001100 $ +#665 +0# +#666 +1# +b00000000000000000000000101001101 $ +#667 +0# +#668 +1# +b00000000000000000000000101001110 $ +#669 +0# +#670 +1# +b00000000000000000000000101001111 $ +#671 +0# +#672 +1# +b00000000000000000000000101010000 $ +#673 +0# +#674 +1# +b00000000000000000000000101010001 $ +#675 +0# +#676 +1# +b00000000000000000000000101010010 $ +#677 +0# +#678 +1# +b00000000000000000000000101010011 $ +#679 +0# +#680 +1# +b00000000000000000000000101010100 $ +#681 +0# +#682 +1# +b00000000000000000000000101010101 $ +#683 +0# +#684 +1# +b00000000000000000000000101010110 $ +#685 +0# +#686 +1# +b00000000000000000000000101010111 $ +#687 +0# +#688 +1# +b00000000000000000000000101011000 $ +#689 +0# +#690 +1# +b00000000000000000000000101011001 $ +#691 +0# +#692 +1# +b00000000000000000000000101011010 $ +#693 +0# +#694 +1# +b00000000000000000000000101011011 $ +#695 +0# +#696 +1# +b00000000000000000000000101011100 $ +#697 +0# +#698 +1# +b00000000000000000000000101011101 $ +#699 +0# +#700 +1# +b00000000000000000000000101011110 $ +#701 +0# +#702 +1# +b00000000000000000000000101011111 $ +#703 +0# +#704 +1# +b00000000000000000000000101100000 $ +#705 +0# +#706 +1# +b00000000000000000000000101100001 $ +#707 +0# +#708 +1# +b00000000000000000000000101100010 $ +#709 +0# +#710 +1# +b00000000000000000000000101100011 $ +#711 +0# +#712 +1# +b00000000000000000000000101100100 $ +#713 +0# +#714 +1# +b00000000000000000000000101100101 $ +#715 +0# +#716 +1# +b00000000000000000000000101100110 $ +#717 +0# +#718 +1# +b00000000000000000000000101100111 $ +#719 +0# +#720 +1# +b00000000000000000000000101101000 $ +#721 +0# +#722 +1# +b00000000000000000000000101101001 $ +#723 +0# +#724 +1# +b00000000000000000000000101101010 $ +#725 +0# +#726 +1# +b00000000000000000000000101101011 $ +#727 +0# +#728 +1# +b00000000000000000000000101101100 $ +#729 +0# +#730 +1# +b00000000000000000000000101101101 $ +#731 +0# +#732 +1# +b00000000000000000000000101101110 $ +#733 +0# +#734 +1# +b00000000000000000000000101101111 $ +#735 +0# +#736 +1# +b00000000000000000000000101110000 $ +#737 +0# +#738 +1# +b00000000000000000000000101110001 $ +#739 +0# +#740 +1# +b00000000000000000000000101110010 $ +#741 +0# +#742 +1# +b00000000000000000000000101110011 $ +#743 +0# +#744 +1# +b00000000000000000000000101110100 $ +#745 +0# +#746 +1# +b00000000000000000000000101110101 $ +#747 +0# +#748 +1# +b00000000000000000000000101110110 $ +#749 +0# +#750 +1# +b00000000000000000000000101110111 $ +#751 +0# +#752 +1# +b00000000000000000000000101111000 $ +#753 +0# +#754 +1# +b00000000000000000000000101111001 $ +#755 +0# +#756 +1# +b00000000000000000000000101111010 $ +#757 +0# +#758 +1# +b00000000000000000000000101111011 $ +#759 +0# +#760 +1# +b00000000000000000000000101111100 $ +#761 +0# +#762 +1# +b00000000000000000000000101111101 $ +#763 +0# +#764 +1# +b00000000000000000000000101111110 $ +#765 +0# +#766 +1# +b00000000000000000000000101111111 $ +#767 +0# +#768 +1# +b00000000000000000000000110000000 $ +#769 +0# +#770 +1# +b00000000000000000000000110000001 $ +#771 +0# +#772 +1# +b00000000000000000000000110000010 $ +#773 +0# +#774 +1# +b00000000000000000000000110000011 $ +#775 +0# +#776 +1# +b00000000000000000000000110000100 $ +#777 +0# +#778 +1# +b00000000000000000000000110000101 $ +#779 +0# +#780 +1# +b00000000000000000000000110000110 $ +#781 +0# +#782 +1# +b00000000000000000000000110000111 $ +#783 +0# +#784 +1# +b00000000000000000000000110001000 $ +#785 +0# +#786 +1# +b00000000000000000000000110001001 $ +#787 +0# +#788 +1# +b00000000000000000000000110001010 $ +#789 +0# +#790 +1# +b00000000000000000000000110001011 $ +#791 +0# +#792 +1# +b00000000000000000000000110001100 $ +#793 +0# +#794 +1# +b00000000000000000000000110001101 $ +#795 +0# +#796 +1# +b00000000000000000000000110001110 $ +#797 +0# +#798 +1# +b00000000000000000000000110001111 $ +#799 +0# +#800 +1# +b00000000000000000000000110010000 $ +#801 +0# +#802 +1# +b00000000000000000000000110010001 $ +#803 +0# +#804 +1# +b00000000000000000000000110010010 $ +#805 +0# +#806 +1# +b00000000000000000000000110010011 $ +#807 +0# +#808 +1# +b00000000000000000000000110010100 $ +#809 +0# +#810 +1# +b00000000000000000000000110010101 $ +#811 +0# +#812 +1# +b00000000000000000000000110010110 $ +#813 +0# +#814 +1# +b00000000000000000000000110010111 $ +#815 +0# +#816 +1# +b00000000000000000000000110011000 $ +#817 +0# +#818 +1# +b00000000000000000000000110011001 $ +#819 +0# +#820 +1# +b00000000000000000000000110011010 $ +#821 +0# +#822 +1# +b00000000000000000000000110011011 $ +#823 +0# +#824 +1# +b00000000000000000000000110011100 $ +#825 +0# +#826 +1# +b00000000000000000000000110011101 $ +#827 +0# +#828 +1# +b00000000000000000000000110011110 $ +#829 +0# +#830 +1# +b00000000000000000000000110011111 $ +#831 +0# +#832 +1# +b00000000000000000000000110100000 $ +#833 +0# +#834 +1# +b00000000000000000000000110100001 $ +#835 +0# +#836 +1# +b00000000000000000000000110100010 $ +#837 +0# +#838 +1# +b00000000000000000000000110100011 $ +#839 +0# +#840 +1# +b00000000000000000000000110100100 $ +#841 +0# +#842 +1# +b00000000000000000000000110100101 $ +#843 +0# +#844 +1# +b00000000000000000000000110100110 $ +#845 +0# +#846 +1# +b00000000000000000000000110100111 $ +#847 +0# +#848 +1# +b00000000000000000000000110101000 $ +#849 +0# +#850 +1# +b00000000000000000000000110101001 $ +#851 +0# +#852 +1# +b00000000000000000000000110101010 $ +#853 +0# +#854 +1# +b00000000000000000000000110101011 $ +#855 +0# +#856 +1# +b00000000000000000000000110101100 $ +#857 +0# +#858 +1# +b00000000000000000000000110101101 $ +#859 +0# +#860 +1# +b00000000000000000000000110101110 $ +#861 +0# +#862 +1# +b00000000000000000000000110101111 $ +#863 +0# +#864 +1# +b00000000000000000000000110110000 $ +#865 +0# +#866 +1# +b00000000000000000000000110110001 $ +#867 +0# +#868 +1# +b00000000000000000000000110110010 $ +#869 +0# +#870 +1# +b00000000000000000000000110110011 $ +#871 +0# +#872 +1# +b00000000000000000000000110110100 $ +#873 +0# +#874 +1# +b00000000000000000000000110110101 $ +#875 +0# +#876 +1# +b00000000000000000000000110110110 $ +#877 +0# +#878 +1# +b00000000000000000000000110110111 $ +#879 +0# +#880 +1# +b00000000000000000000000110111000 $ +#881 +0# +#882 +1# +b00000000000000000000000110111001 $ +#883 +0# +#884 +1# +b00000000000000000000000110111010 $ +#885 +0# +#886 +1# +b00000000000000000000000110111011 $ +#887 +0# +#888 +1# +b00000000000000000000000110111100 $ +#889 +0# +#890 +1# +b00000000000000000000000110111101 $ +#891 +0# +#892 +1# +b00000000000000000000000110111110 $ +#893 +0# +#894 +1# +b00000000000000000000000110111111 $ +#895 +0# +#896 +1# +b00000000000000000000000111000000 $ +#897 +0# +#898 +1# +b00000000000000000000000111000001 $ +#899 +0# +#900 +1# +b00000000000000000000000111000010 $ +#901 +0# +#902 +1# +b00000000000000000000000111000011 $ +#903 +0# +#904 +1# +b00000000000000000000000111000100 $ +#905 +0# +#906 +1# +b00000000000000000000000111000101 $ +#907 +0# +#908 +1# +b00000000000000000000000111000110 $ +#909 +0# +#910 +1# +b00000000000000000000000111000111 $ +#911 +0# +#912 +1# +b00000000000000000000000111001000 $ +#913 +0# +#914 +1# +b00000000000000000000000111001001 $ +#915 +0# +#916 +1# +b00000000000000000000000111001010 $ +#917 +0# +#918 +1# +b00000000000000000000000111001011 $ +#919 +0# +#920 +1# +b00000000000000000000000111001100 $ +#921 +0# +#922 +1# +b00000000000000000000000111001101 $ +#923 +0# +#924 +1# +b00000000000000000000000111001110 $ +#925 +0# +#926 +1# +b00000000000000000000000111001111 $ +#927 +0# +#928 +1# +b00000000000000000000000111010000 $ +#929 +0# +#930 +1# +b00000000000000000000000111010001 $ +#931 +0# +#932 +1# +b00000000000000000000000111010010 $ +#933 +0# +#934 +1# +b00000000000000000000000111010011 $ +#935 +0# +#936 +1# +b00000000000000000000000111010100 $ +#937 +0# +#938 +1# +b00000000000000000000000111010101 $ +#939 +0# +#940 +1# +b00000000000000000000000111010110 $ +#941 +0# +#942 +1# +b00000000000000000000000111010111 $ +#943 +0# +#944 +1# +b00000000000000000000000111011000 $ +#945 +0# +#946 +1# +b00000000000000000000000111011001 $ +#947 +0# +#948 +1# +b00000000000000000000000111011010 $ +#949 +0# +#950 +1# +b00000000000000000000000111011011 $ +#951 +0# +#952 +1# +b00000000000000000000000111011100 $ +#953 +0# +#954 +1# +b00000000000000000000000111011101 $ +#955 +0# +#956 +1# +b00000000000000000000000111011110 $ +#957 +0# +#958 +1# +b00000000000000000000000111011111 $ +#959 +0# +#960 +1# +b00000000000000000000000111100000 $ +#961 +0# +#962 +1# +b00000000000000000000000111100001 $ +#963 +0# +#964 +1# +b00000000000000000000000111100010 $ +#965 +0# +#966 +1# +b00000000000000000000000111100011 $ +#967 +0# +#968 +1# +b00000000000000000000000111100100 $ +#969 +0# +#970 +1# +b00000000000000000000000111100101 $ +#971 +0# +#972 +1# +b00000000000000000000000111100110 $ +#973 +0# +#974 +1# +b00000000000000000000000111100111 $ +#975 +0# +#976 +1# +b00000000000000000000000111101000 $ +#977 +0# +#978 +1# +b00000000000000000000000111101001 $ +#979 +0# +#980 +1# +b00000000000000000000000111101010 $ +#981 +0# +#982 +1# +b00000000000000000000000111101011 $ +#983 +0# +#984 +1# +b00000000000000000000000111101100 $ +#985 +0# +#986 +1# +b00000000000000000000000111101101 $ +#987 +0# +#988 +1# +b00000000000000000000000111101110 $ +#989 +0# +#990 +1# +b00000000000000000000000111101111 $ +#991 +0# +#992 +1# +b00000000000000000000000111110000 $ +#993 +0# +#994 +1# +b00000000000000000000000111110001 $ +#995 +0# +#996 +1# +b00000000000000000000000111110010 $ +#997 +0# +#998 +1# +b00000000000000000000000111110011 $ +#999 +0# +#1000 +1# +b00000000000000000000000111110100 $ +#1001 +0# +#1002 +1# +b00000000000000000000000111110101 $ +#1003 +0# +#1004 +1# +b00000000000000000000000111110110 $ +#1005 +0# +#1006 +1# +b00000000000000000000000111110111 $ +#1007 +0# +#1008 +1# +b00000000000000000000000111111000 $ +#1009 +0# +#1010 +1# +b00000000000000000000000111111001 $ +#1011 +0# +#1012 +1# +b00000000000000000000000111111010 $ +#1013 +0# +#1014 +1# +b00000000000000000000000111111011 $ +#1015 +0# +#1016 +1# +b00000000000000000000000111111100 $ +#1017 +0# +#1018 +1# +b00000000000000000000000111111101 $ +#1019 +0# +#1020 +1# +b00000000000000000000000111111110 $ +#1021 +0# +#1022 +1# +b00000000000000000000000111111111 $ +#1023 +0# +#1024 +1# +b00000000000000000000001000000000 $ +#1025 +0# +#1026 +1# +b00000000000000000000001000000001 $ +#1027 +0# +#1028 +1# +b00000000000000000000001000000010 $ +#1029 +0# +#1030 +1# +b00000000000000000000001000000011 $ +#1031 +0# +#1032 +1# +b00000000000000000000001000000100 $ +#1033 +0# +#1034 +1# +b00000000000000000000001000000101 $ +#1035 +0# +#1036 +1# +b00000000000000000000001000000110 $ +#1037 +0# +#1038 +1# +b00000000000000000000001000000111 $ +#1039 +0# +#1040 +1# +b00000000000000000000001000001000 $ +#1041 +0# +#1042 +1# +b00000000000000000000001000001001 $ +#1043 +0# +#1044 +1# +b00000000000000000000001000001010 $ +#1045 +0# +#1046 +1# +b00000000000000000000001000001011 $ +#1047 +0# +#1048 +1# +b00000000000000000000001000001100 $ +#1049 +0# +#1050 +1# +b00000000000000000000001000001101 $ +#1051 +0# +#1052 +1# +b00000000000000000000001000001110 $ +#1053 +0# +#1054 +1# +b00000000000000000000001000001111 $ +#1055 +0# +#1056 +1# +b00000000000000000000001000010000 $ +#1057 +0# +#1058 +1# +b00000000000000000000001000010001 $ +#1059 +0# +#1060 +1# +b00000000000000000000001000010010 $ +#1061 +0# +#1062 +1# +b00000000000000000000001000010011 $ +#1063 +0# +#1064 +1# +b00000000000000000000001000010100 $ +#1065 +0# +#1066 +1# +b00000000000000000000001000010101 $ +#1067 +0# +#1068 +1# +b00000000000000000000001000010110 $ +#1069 +0# +#1070 +1# +b00000000000000000000001000010111 $ +#1071 +0# +#1072 +1# +b00000000000000000000001000011000 $ +#1073 +0# +#1074 +1# +b00000000000000000000001000011001 $ +#1075 +0# +#1076 +1# +b00000000000000000000001000011010 $ +#1077 +0# +#1078 +1# +b00000000000000000000001000011011 $ +#1079 +0# +#1080 +1# +b00000000000000000000001000011100 $ +#1081 +0# +#1082 +1# +b00000000000000000000001000011101 $ +#1083 +0# +#1084 +1# +b00000000000000000000001000011110 $ +#1085 +0# +#1086 +1# +b00000000000000000000001000011111 $ +#1087 +0# +#1088 +1# +b00000000000000000000001000100000 $ +#1089 +0# +#1090 +1# +b00000000000000000000001000100001 $ +#1091 +0# +#1092 +1# +b00000000000000000000001000100010 $ +#1093 +0# +#1094 +1# +b00000000000000000000001000100011 $ +#1095 +0# +#1096 +1# +b00000000000000000000001000100100 $ +#1097 +0# +#1098 +1# +b00000000000000000000001000100101 $ +#1099 +0# +#1100 +1# +b00000000000000000000001000100110 $ +#1101 +0# +#1102 +1# +b00000000000000000000001000100111 $ +#1103 +0# +#1104 +1# +b00000000000000000000001000101000 $ +#1105 +0# +#1106 +1# +b00000000000000000000001000101001 $ +#1107 +0# +#1108 +1# +b00000000000000000000001000101010 $ +#1109 +0# +#1110 +1# +b00000000000000000000001000101011 $ +#1111 +0# +#1112 +1# +b00000000000000000000001000101100 $ +#1113 +0# +#1114 +1# +b00000000000000000000001000101101 $ +#1115 +0# +#1116 +1# +b00000000000000000000001000101110 $ +#1117 +0# +#1118 +1# +b00000000000000000000001000101111 $ +#1119 +0# +#1120 +1# +b00000000000000000000001000110000 $ +#1121 +0# +#1122 +1# +b00000000000000000000001000110001 $ +#1123 +0# +#1124 +1# +b00000000000000000000001000110010 $ +#1125 +0# +#1126 +1# +b00000000000000000000001000110011 $ +#1127 +0# +#1128 +1# +b00000000000000000000001000110100 $ +#1129 +0# +#1130 +1# +b00000000000000000000001000110101 $ +#1131 +0# +#1132 +1# +b00000000000000000000001000110110 $ +#1133 +0# +#1134 +1# +b00000000000000000000001000110111 $ +#1135 +0# +#1136 +1# +b00000000000000000000001000111000 $ +#1137 +0# +#1138 +1# +b00000000000000000000001000111001 $ +#1139 +0# +#1140 +1# +b00000000000000000000001000111010 $ +#1141 +0# +#1142 +1# +b00000000000000000000001000111011 $ +#1143 +0# +#1144 +1# +b00000000000000000000001000111100 $ +#1145 +0# +#1146 +1# +b00000000000000000000001000111101 $ +#1147 +0# +#1148 +1# +b00000000000000000000001000111110 $ +#1149 +0# +#1150 +1# +b00000000000000000000001000111111 $ +#1151 +0# +#1152 +1# +b00000000000000000000001001000000 $ +#1153 +0# +#1154 +1# +b00000000000000000000001001000001 $ +#1155 +0# +#1156 +1# +b00000000000000000000001001000010 $ +#1157 +0# +#1158 +1# +b00000000000000000000001001000011 $ +#1159 +0# +#1160 +1# +b00000000000000000000001001000100 $ +#1161 +0# +#1162 +1# +b00000000000000000000001001000101 $ +#1163 +0# +#1164 +1# +b00000000000000000000001001000110 $ +#1165 +0# +#1166 +1# +b00000000000000000000001001000111 $ +#1167 +0# +#1168 +1# +b00000000000000000000001001001000 $ +#1169 +0# +#1170 +1# +b00000000000000000000001001001001 $ +#1171 +0# +#1172 +1# +b00000000000000000000001001001010 $ +#1173 +0# +#1174 +1# +b00000000000000000000001001001011 $ +#1175 +0# +#1176 +1# +b00000000000000000000001001001100 $ +#1177 +0# +#1178 +1# +b00000000000000000000001001001101 $ +#1179 +0# +#1180 +1# +b00000000000000000000001001001110 $ +#1181 +0# +#1182 +1# +b00000000000000000000001001001111 $ +#1183 +0# +#1184 +1# +b00000000000000000000001001010000 $ +#1185 +0# +#1186 +1# +b00000000000000000000001001010001 $ +#1187 +0# +#1188 +1# +b00000000000000000000001001010010 $ +#1189 +0# +#1190 +1# +b00000000000000000000001001010011 $ +#1191 +0# +#1192 +1# +b00000000000000000000001001010100 $ +#1193 +0# +#1194 +1# +b00000000000000000000001001010101 $ +#1195 +0# +#1196 +1# +b00000000000000000000001001010110 $ +#1197 +0# +#1198 +1# +b00000000000000000000001001010111 $ +#1199 +0# +#1200 +1# +b00000000000000000000001001011000 $ +#1201 +0# +#1202 +1# +b00000000000000000000001001011001 $ +#1203 +0# +#1204 +1# +b00000000000000000000001001011010 $ +#1205 +0# +#1206 +1# +b00000000000000000000001001011011 $ +#1207 +0# +#1208 +1# +b00000000000000000000001001011100 $ +#1209 +0# +#1210 +1# +b00000000000000000000001001011101 $ +#1211 +0# +#1212 +1# +b00000000000000000000001001011110 $ +#1213 +0# +#1214 +1# +b00000000000000000000001001011111 $ +#1215 +0# +#1216 +1# +b00000000000000000000001001100000 $ +#1217 +0# +#1218 +1# +b00000000000000000000001001100001 $ +#1219 +0# +#1220 +1# +b00000000000000000000001001100010 $ +#1221 +0# +#1222 +1# +b00000000000000000000001001100011 $ +#1223 +0# +#1224 +1# +b00000000000000000000001001100100 $ +#1225 +0# +#1226 +1# +b00000000000000000000001001100101 $ +#1227 +0# +#1228 +1# +b00000000000000000000001001100110 $ +#1229 +0# +#1230 +1# +b00000000000000000000001001100111 $ +#1231 +0# +#1232 +1# +b00000000000000000000001001101000 $ +#1233 +0# +#1234 +1# +b00000000000000000000001001101001 $ +#1235 +0# +#1236 +1# +b00000000000000000000001001101010 $ +#1237 +0# +#1238 +1# +b00000000000000000000001001101011 $ +#1239 +0# +#1240 +1# +b00000000000000000000001001101100 $ +#1241 +0# +#1242 +1# +b00000000000000000000001001101101 $ +#1243 +0# +#1244 +1# +b00000000000000000000001001101110 $ +#1245 +0# +#1246 +1# +b00000000000000000000001001101111 $ +#1247 +0# +#1248 +1# +b00000000000000000000001001110000 $ +#1249 +0# +#1250 +1# +b00000000000000000000001001110001 $ +#1251 +0# +#1252 +1# +b00000000000000000000001001110010 $ +#1253 +0# +#1254 +1# +b00000000000000000000001001110011 $ +#1255 +0# +#1256 +1# +b00000000000000000000001001110100 $ +#1257 +0# +#1258 +1# +b00000000000000000000001001110101 $ +#1259 +0# +#1260 +1# +b00000000000000000000001001110110 $ +#1261 +0# +#1262 +1# +b00000000000000000000001001110111 $ +#1263 +0# +#1264 +1# +b00000000000000000000001001111000 $ +#1265 +0# +#1266 +1# +b00000000000000000000001001111001 $ +#1267 +0# +#1268 +1# +b00000000000000000000001001111010 $ +#1269 +0# +#1270 +1# +b00000000000000000000001001111011 $ +#1271 +0# +#1272 +1# +b00000000000000000000001001111100 $ +#1273 +0# +#1274 +1# +b00000000000000000000001001111101 $ +#1275 +0# +#1276 +1# +b00000000000000000000001001111110 $ +#1277 +0# +#1278 +1# +b00000000000000000000001001111111 $ +#1279 +0# +#1280 +1# +b00000000000000000000001010000000 $ +#1281 +0# +#1282 +1# +b00000000000000000000001010000001 $ +#1283 +0# +#1284 +1# +b00000000000000000000001010000010 $ +#1285 +0# +#1286 +1# +b00000000000000000000001010000011 $ +#1287 +0# +#1288 +1# +b00000000000000000000001010000100 $ +#1289 +0# +#1290 +1# +b00000000000000000000001010000101 $ +#1291 +0# +#1292 +1# +b00000000000000000000001010000110 $ +#1293 +0# +#1294 +1# +b00000000000000000000001010000111 $ +#1295 +0# +#1296 +1# +b00000000000000000000001010001000 $ +#1297 +0# +#1298 +1# +b00000000000000000000001010001001 $ +#1299 +0# +#1300 +1# +b00000000000000000000001010001010 $ +#1301 +0# +#1302 +1# +b00000000000000000000001010001011 $ +#1303 +0# +#1304 +1# +b00000000000000000000001010001100 $ +#1305 +0# +#1306 +1# +b00000000000000000000001010001101 $ +#1307 +0# +#1308 +1# +b00000000000000000000001010001110 $ +#1309 +0# +#1310 +1# +b00000000000000000000001010001111 $ +#1311 +0# +#1312 +1# +b00000000000000000000001010010000 $ +#1313 +0# +#1314 +1# +b00000000000000000000001010010001 $ +#1315 +0# +#1316 +1# +b00000000000000000000001010010010 $ +#1317 +0# +#1318 +1# +b00000000000000000000001010010011 $ +#1319 +0# +#1320 +1# +b00000000000000000000001010010100 $ +#1321 +0# +#1322 +1# +b00000000000000000000001010010101 $ +#1323 +0# +#1324 +1# +b00000000000000000000001010010110 $ +#1325 +0# +#1326 +1# +b00000000000000000000001010010111 $ +#1327 +0# +#1328 +1# +b00000000000000000000001010011000 $ +#1329 +0# +#1330 +1# +b00000000000000000000001010011001 $ +#1331 +0# +#1332 +1# +b00000000000000000000001010011010 $ +#1333 +0# +#1334 +1# +b00000000000000000000001010011011 $ +#1335 +0# +#1336 +1# +b00000000000000000000001010011100 $ +#1337 +0# +#1338 +1# +b00000000000000000000001010011101 $ +#1339 +0# +#1340 +1# +b00000000000000000000001010011110 $ +#1341 +0# +#1342 +1# +b00000000000000000000001010011111 $ +#1343 +0# +#1344 +1# +b00000000000000000000001010100000 $ +#1345 +0# +#1346 +1# +b00000000000000000000001010100001 $ +#1347 +0# +#1348 +1# +b00000000000000000000001010100010 $ +#1349 +0# +#1350 +1# +b00000000000000000000001010100011 $ +#1351 +0# +#1352 +1# +b00000000000000000000001010100100 $ +#1353 +0# +#1354 +1# +b00000000000000000000001010100101 $ +#1355 +0# +#1356 +1# +b00000000000000000000001010100110 $ +#1357 +0# +#1358 +1# +b00000000000000000000001010100111 $ +#1359 +0# +#1360 +1# +b00000000000000000000001010101000 $ +#1361 +0# +#1362 +1# +b00000000000000000000001010101001 $ +#1363 +0# +#1364 +1# +b00000000000000000000001010101010 $ +#1365 +0# +#1366 +1# +b00000000000000000000001010101011 $ +#1367 +0# +#1368 +1# +b00000000000000000000001010101100 $ +#1369 +0# +#1370 +1# +b00000000000000000000001010101101 $ +#1371 +0# +#1372 +1# +b00000000000000000000001010101110 $ +#1373 +0# +#1374 +1# +b00000000000000000000001010101111 $ +#1375 +0# +#1376 +1# +b00000000000000000000001010110000 $ +#1377 +0# +#1378 +1# +b00000000000000000000001010110001 $ +#1379 +0# +#1380 +1# +b00000000000000000000001010110010 $ +#1381 +0# +#1382 +1# +b00000000000000000000001010110011 $ +#1383 +0# +#1384 +1# +b00000000000000000000001010110100 $ +#1385 +0# +#1386 +1# +b00000000000000000000001010110101 $ +#1387 +0# +#1388 +1# +b00000000000000000000001010110110 $ +#1389 +0# +#1390 +1# +b00000000000000000000001010110111 $ +#1391 +0# +#1392 +1# +b00000000000000000000001010111000 $ +#1393 +0# +#1394 +1# +b00000000000000000000001010111001 $ +#1395 +0# +#1396 +1# +b00000000000000000000001010111010 $ +#1397 +0# +#1398 +1# +b00000000000000000000001010111011 $ +#1399 +0# +#1400 +1# +b00000000000000000000001010111100 $ +#1401 +0# +#1402 +1# +b00000000000000000000001010111101 $ +#1403 +0# +#1404 +1# +b00000000000000000000001010111110 $ +#1405 +0# +#1406 +1# +b00000000000000000000001010111111 $ +#1407 +0# +#1408 +1# +b00000000000000000000001011000000 $ +#1409 +0# +#1410 +1# +b00000000000000000000001011000001 $ +#1411 +0# +#1412 +1# +b00000000000000000000001011000010 $ +#1413 +0# +#1414 +1# +b00000000000000000000001011000011 $ +#1415 +0# +#1416 +1# +b00000000000000000000001011000100 $ +#1417 +0# +#1418 +1# +b00000000000000000000001011000101 $ +#1419 +0# +#1420 +1# +b00000000000000000000001011000110 $ +#1421 +0# +#1422 +1# +b00000000000000000000001011000111 $ +#1423 +0# +#1424 +1# +b00000000000000000000001011001000 $ +#1425 +0# +#1426 +1# +b00000000000000000000001011001001 $ +#1427 +0# +#1428 +1# +b00000000000000000000001011001010 $ +#1429 +0# +#1430 +1# +b00000000000000000000001011001011 $ +#1431 +0# +#1432 +1# +b00000000000000000000001011001100 $ +#1433 +0# +#1434 +1# +b00000000000000000000001011001101 $ +#1435 +0# +#1436 +1# +b00000000000000000000001011001110 $ +#1437 +0# +#1438 +1# +b00000000000000000000001011001111 $ +#1439 +0# +#1440 +1# +b00000000000000000000001011010000 $ +#1441 +0# +#1442 +1# +b00000000000000000000001011010001 $ +#1443 +0# +#1444 +1# +b00000000000000000000001011010010 $ +#1445 +0# +#1446 +1# +b00000000000000000000001011010011 $ +#1447 +0# +#1448 +1# +b00000000000000000000001011010100 $ +#1449 +0# +#1450 +1# +b00000000000000000000001011010101 $ +#1451 +0# +#1452 +1# +b00000000000000000000001011010110 $ +#1453 +0# +#1454 +1# +b00000000000000000000001011010111 $ +#1455 +0# +#1456 +1# +b00000000000000000000001011011000 $ +#1457 +0# +#1458 +1# +b00000000000000000000001011011001 $ +#1459 +0# +#1460 +1# +b00000000000000000000001011011010 $ +#1461 +0# +#1462 +1# +b00000000000000000000001011011011 $ +#1463 +0# +#1464 +1# +b00000000000000000000001011011100 $ +#1465 +0# +#1466 +1# +b00000000000000000000001011011101 $ +#1467 +0# +#1468 +1# +b00000000000000000000001011011110 $ +#1469 +0# +#1470 +1# +b00000000000000000000001011011111 $ +#1471 +0# +#1472 +1# +b00000000000000000000001011100000 $ +#1473 +0# +#1474 +1# +b00000000000000000000001011100001 $ +#1475 +0# +#1476 +1# +b00000000000000000000001011100010 $ +#1477 +0# +#1478 +1# +b00000000000000000000001011100011 $ +#1479 +0# +#1480 +1# +b00000000000000000000001011100100 $ +#1481 +0# +#1482 +1# +b00000000000000000000001011100101 $ +#1483 +0# +#1484 +1# +b00000000000000000000001011100110 $ +#1485 +0# +#1486 +1# +b00000000000000000000001011100111 $ +#1487 +0# +#1488 +1# +b00000000000000000000001011101000 $ +#1489 +0# +#1490 +1# +b00000000000000000000001011101001 $ +#1491 +0# +#1492 +1# +b00000000000000000000001011101010 $ +#1493 +0# +#1494 +1# +b00000000000000000000001011101011 $ +#1495 +0# +#1496 +1# +b00000000000000000000001011101100 $ +#1497 +0# +#1498 +1# +b00000000000000000000001011101101 $ +#1499 +0# +#1500 +1# +b00000000000000000000001011101110 $ +#1501 +0# +#1502 +1# +b00000000000000000000001011101111 $ +#1503 +0# +#1504 +1# +b00000000000000000000001011110000 $ +#1505 +0# +#1506 +1# +b00000000000000000000001011110001 $ +#1507 +0# +#1508 +1# +b00000000000000000000001011110010 $ +#1509 +0# +#1510 +1# +b00000000000000000000001011110011 $ +#1511 +0# +#1512 +1# +b00000000000000000000001011110100 $ +#1513 +0# +#1514 +1# +b00000000000000000000001011110101 $ +#1515 +0# +#1516 +1# +b00000000000000000000001011110110 $ +#1517 +0# +#1518 +1# +b00000000000000000000001011110111 $ +#1519 +0# +#1520 +1# +b00000000000000000000001011111000 $ +#1521 +0# +#1522 +1# +b00000000000000000000001011111001 $ +#1523 +0# +#1524 +1# +b00000000000000000000001011111010 $ +#1525 +0# +#1526 +1# +b00000000000000000000001011111011 $ +#1527 +0# +#1528 +1# +b00000000000000000000001011111100 $ +#1529 +0# +#1530 +1# +b00000000000000000000001011111101 $ +#1531 +0# +#1532 +1# +b00000000000000000000001011111110 $ +#1533 +0# +#1534 +1# +b00000000000000000000001011111111 $ +#1535 +0# +#1536 +1# +b00000000000000000000001100000000 $ +#1537 +0# +#1538 +1# +b00000000000000000000001100000001 $ +#1539 +0# +#1540 +1# +b00000000000000000000001100000010 $ +#1541 +0# +#1542 +1# +b00000000000000000000001100000011 $ +#1543 +0# +#1544 +1# +b00000000000000000000001100000100 $ +#1545 +0# +#1546 +1# +b00000000000000000000001100000101 $ +#1547 +0# +#1548 +1# +b00000000000000000000001100000110 $ +#1549 +0# +#1550 +1# +b00000000000000000000001100000111 $ +#1551 +0# +#1552 +1# +b00000000000000000000001100001000 $ +#1553 +0# +#1554 +1# +b00000000000000000000001100001001 $ +#1555 +0# +#1556 +1# +b00000000000000000000001100001010 $ +#1557 +0# +#1558 +1# +b00000000000000000000001100001011 $ +#1559 +0# +#1560 +1# +b00000000000000000000001100001100 $ +#1561 +0# +#1562 +1# +b00000000000000000000001100001101 $ +#1563 +0# +#1564 +1# +b00000000000000000000001100001110 $ +#1565 +0# +#1566 +1# +b00000000000000000000001100001111 $ +#1567 +0# +#1568 +1# +b00000000000000000000001100010000 $ +#1569 +0# +#1570 +1# +b00000000000000000000001100010001 $ +#1571 +0# +#1572 +1# +b00000000000000000000001100010010 $ +#1573 +0# +#1574 +1# +b00000000000000000000001100010011 $ +#1575 +0# +#1576 +1# +b00000000000000000000001100010100 $ +#1577 +0# +#1578 +1# +b00000000000000000000001100010101 $ +#1579 +0# +#1580 +1# +b00000000000000000000001100010110 $ +#1581 +0# +#1582 +1# +b00000000000000000000001100010111 $ +#1583 +0# +#1584 +1# +b00000000000000000000001100011000 $ +#1585 +0# +#1586 +1# +b00000000000000000000001100011001 $ +#1587 +0# +#1588 +1# +b00000000000000000000001100011010 $ +#1589 +0# +#1590 +1# +b00000000000000000000001100011011 $ +#1591 +0# +#1592 +1# +b00000000000000000000001100011100 $ +#1593 +0# +#1594 +1# +b00000000000000000000001100011101 $ +#1595 +0# +#1596 +1# +b00000000000000000000001100011110 $ +#1597 +0# +#1598 +1# +b00000000000000000000001100011111 $ +#1599 +0# +#1600 +1# +b00000000000000000000001100100000 $ +#1601 +0# +#1602 +1# +b00000000000000000000001100100001 $ +#1603 +0# +#1604 +1# +b00000000000000000000001100100010 $ +#1605 +0# +#1606 +1# +b00000000000000000000001100100011 $ +#1607 +0# +#1608 +1# +b00000000000000000000001100100100 $ +#1609 +0# +#1610 +1# +b00000000000000000000001100100101 $ +#1611 +0# +#1612 +1# +b00000000000000000000001100100110 $ +#1613 +0# +#1614 +1# +b00000000000000000000001100100111 $ +#1615 +0# +#1616 +1# +b00000000000000000000001100101000 $ +#1617 +0# +#1618 +1# +b00000000000000000000001100101001 $ +#1619 +0# +#1620 +1# +b00000000000000000000001100101010 $ +#1621 +0# +#1622 +1# +b00000000000000000000001100101011 $ +#1623 +0# +#1624 +1# +b00000000000000000000001100101100 $ +#1625 +0# +#1626 +1# +b00000000000000000000001100101101 $ +#1627 +0# +#1628 +1# +b00000000000000000000001100101110 $ +#1629 +0# +#1630 +1# +b00000000000000000000001100101111 $ +#1631 +0# +#1632 +1# +b00000000000000000000001100110000 $ +#1633 +0# +#1634 +1# +b00000000000000000000001100110001 $ +#1635 +0# +#1636 +1# +b00000000000000000000001100110010 $ +#1637 +0# +#1638 +1# +b00000000000000000000001100110011 $ +#1639 +0# +#1640 +1# +b00000000000000000000001100110100 $ +#1641 +0# +#1642 +1# +b00000000000000000000001100110101 $ +#1643 +0# +#1644 +1# +b00000000000000000000001100110110 $ +#1645 +0# +#1646 +1# +b00000000000000000000001100110111 $ +#1647 +0# +#1648 +1# +b00000000000000000000001100111000 $ +#1649 +0# +#1650 +1# +b00000000000000000000001100111001 $ +#1651 +0# +#1652 +1# +b00000000000000000000001100111010 $ +#1653 +0# +#1654 +1# +b00000000000000000000001100111011 $ +#1655 +0# +#1656 +1# +b00000000000000000000001100111100 $ +#1657 +0# +#1658 +1# +b00000000000000000000001100111101 $ +#1659 +0# +#1660 +1# +b00000000000000000000001100111110 $ +#1661 +0# +#1662 +1# +b00000000000000000000001100111111 $ +#1663 +0# +#1664 +1# +b00000000000000000000001101000000 $ +#1665 +0# +#1666 +1# +b00000000000000000000001101000001 $ +#1667 +0# +#1668 +1# +b00000000000000000000001101000010 $ +#1669 +0# +#1670 +1# +b00000000000000000000001101000011 $ +#1671 +0# +#1672 +1# +b00000000000000000000001101000100 $ +#1673 +0# +#1674 +1# +b00000000000000000000001101000101 $ +#1675 +0# +#1676 +1# +b00000000000000000000001101000110 $ +#1677 +0# +#1678 +1# +b00000000000000000000001101000111 $ +#1679 +0# +#1680 +1# +b00000000000000000000001101001000 $ +#1681 +0# +#1682 +1# +b00000000000000000000001101001001 $ +#1683 +0# +#1684 +1# +b00000000000000000000001101001010 $ +#1685 +0# +#1686 +1# +b00000000000000000000001101001011 $ +#1687 +0# +#1688 +1# +b00000000000000000000001101001100 $ +#1689 +0# +#1690 +1# +b00000000000000000000001101001101 $ +#1691 +0# +#1692 +1# +b00000000000000000000001101001110 $ +#1693 +0# +#1694 +1# +b00000000000000000000001101001111 $ +#1695 +0# +#1696 +1# +b00000000000000000000001101010000 $ +#1697 +0# +#1698 +1# +b00000000000000000000001101010001 $ +#1699 +0# +#1700 +1# +b00000000000000000000001101010010 $ +#1701 +0# +#1702 +1# +b00000000000000000000001101010011 $ +#1703 +0# +#1704 +1# +b00000000000000000000001101010100 $ +#1705 +0# +#1706 +1# +b00000000000000000000001101010101 $ +#1707 +0# +#1708 +1# +b00000000000000000000001101010110 $ +#1709 +0# +#1710 +1# +b00000000000000000000001101010111 $ +#1711 +0# +#1712 +1# +b00000000000000000000001101011000 $ +#1713 +0# +#1714 +1# +b00000000000000000000001101011001 $ +#1715 +0# +#1716 +1# +b00000000000000000000001101011010 $ +#1717 +0# +#1718 +1# +b00000000000000000000001101011011 $ +#1719 +0# +#1720 +1# +b00000000000000000000001101011100 $ +#1721 +0# +#1722 +1# +b00000000000000000000001101011101 $ +#1723 +0# +#1724 +1# +b00000000000000000000001101011110 $ +#1725 +0# +#1726 +1# +b00000000000000000000001101011111 $ +#1727 +0# +#1728 +1# +b00000000000000000000001101100000 $ +#1729 +0# +#1730 +1# +b00000000000000000000001101100001 $ +#1731 +0# +#1732 +1# +b00000000000000000000001101100010 $ +#1733 +0# +#1734 +1# +b00000000000000000000001101100011 $ +#1735 +0# +#1736 +1# +b00000000000000000000001101100100 $ +#1737 +0# +#1738 +1# +b00000000000000000000001101100101 $ +#1739 +0# +#1740 +1# +b00000000000000000000001101100110 $ +#1741 +0# +#1742 +1# +b00000000000000000000001101100111 $ +#1743 +0# +#1744 +1# +b00000000000000000000001101101000 $ +#1745 +0# +#1746 +1# +b00000000000000000000001101101001 $ +#1747 +0# +#1748 +1# +b00000000000000000000001101101010 $ +#1749 +0# +#1750 +1# +b00000000000000000000001101101011 $ +#1751 +0# +#1752 +1# +b00000000000000000000001101101100 $ +#1753 +0# +#1754 +1# +b00000000000000000000001101101101 $ +#1755 +0# +#1756 +1# +b00000000000000000000001101101110 $ +#1757 +0# +#1758 +1# +b00000000000000000000001101101111 $ +#1759 +0# +#1760 +1# +b00000000000000000000001101110000 $ +#1761 +0# +#1762 +1# +b00000000000000000000001101110001 $ +#1763 +0# +#1764 +1# +b00000000000000000000001101110010 $ +#1765 +0# +#1766 +1# +b00000000000000000000001101110011 $ +#1767 +0# +#1768 +1# +b00000000000000000000001101110100 $ +#1769 +0# +#1770 +1# +b00000000000000000000001101110101 $ +#1771 +0# +#1772 +1# +b00000000000000000000001101110110 $ +#1773 +0# +#1774 +1# +b00000000000000000000001101110111 $ +#1775 +0# +#1776 +1# +b00000000000000000000001101111000 $ +#1777 +0# +#1778 +1# +b00000000000000000000001101111001 $ +#1779 +0# +#1780 +1# +b00000000000000000000001101111010 $ +#1781 +0# +#1782 +1# +b00000000000000000000001101111011 $ +#1783 +0# +#1784 +1# +b00000000000000000000001101111100 $ +#1785 +0# +#1786 +1# +b00000000000000000000001101111101 $ +#1787 +0# +#1788 +1# +b00000000000000000000001101111110 $ +#1789 +0# +#1790 +1# +b00000000000000000000001101111111 $ +#1791 +0# +#1792 +1# +b00000000000000000000001110000000 $ +#1793 +0# +#1794 +1# +b00000000000000000000001110000001 $ +#1795 +0# +#1796 +1# +b00000000000000000000001110000010 $ +#1797 +0# +#1798 +1# +b00000000000000000000001110000011 $ +#1799 +0# +#1800 +1# +b00000000000000000000001110000100 $ +#1801 +0# +#1802 +1# +b00000000000000000000001110000101 $ +#1803 +0# +#1804 +1# +b00000000000000000000001110000110 $ +#1805 +0# +#1806 +1# +b00000000000000000000001110000111 $ +#1807 +0# +#1808 +1# +b00000000000000000000001110001000 $ +#1809 +0# +#1810 +1# +b00000000000000000000001110001001 $ +#1811 +0# +#1812 +1# +b00000000000000000000001110001010 $ +#1813 +0# +#1814 +1# +b00000000000000000000001110001011 $ +#1815 +0# +#1816 +1# +b00000000000000000000001110001100 $ +#1817 +0# +#1818 +1# +b00000000000000000000001110001101 $ +#1819 +0# +#1820 +1# +b00000000000000000000001110001110 $ +#1821 +0# +#1822 +1# +b00000000000000000000001110001111 $ +#1823 +0# +#1824 +1# +b00000000000000000000001110010000 $ +#1825 +0# +#1826 +1# +b00000000000000000000001110010001 $ +#1827 +0# +#1828 +1# +b00000000000000000000001110010010 $ +#1829 +0# +#1830 +1# +b00000000000000000000001110010011 $ +#1831 +0# +#1832 +1# +b00000000000000000000001110010100 $ +#1833 +0# +#1834 +1# +b00000000000000000000001110010101 $ +#1835 +0# +#1836 +1# +b00000000000000000000001110010110 $ +#1837 +0# +#1838 +1# +b00000000000000000000001110010111 $ +#1839 +0# +#1840 +1# +b00000000000000000000001110011000 $ +#1841 +0# +#1842 +1# +b00000000000000000000001110011001 $ +#1843 +0# +#1844 +1# +b00000000000000000000001110011010 $ +#1845 +0# +#1846 +1# +b00000000000000000000001110011011 $ +#1847 +0# +#1848 +1# +b00000000000000000000001110011100 $ +#1849 +0# +#1850 +1# +b00000000000000000000001110011101 $ +#1851 +0# +#1852 +1# +b00000000000000000000001110011110 $ +#1853 +0# +#1854 +1# +b00000000000000000000001110011111 $ +#1855 +0# +#1856 +1# +b00000000000000000000001110100000 $ +#1857 +0# +#1858 +1# +b00000000000000000000001110100001 $ +#1859 +0# +#1860 +1# +b00000000000000000000001110100010 $ +#1861 +0# +b00000000000000000000001110100010 $ +#1862 +1# +b00000000000000000000001110100011 $ +#1863 +0# +#1864 +1# +b00000000000000000000001110100100 $ +#1865 +0# +#1866 +1# +b00000000000000000000001110100101 $ +#1867 +0# +#1868 +1# +b00000000000000000000001110100110 $ +#1869 +0# +#1870 +1# +b00000000000000000000001110100111 $ +#1871 +0# +#1872 +1# +b00000000000000000000001110101000 $ +#1873 +0# +#1874 +1# +b00000000000000000000001110101001 $ +#1875 +0# +#1876 +1# +b00000000000000000000001110101010 $ +#1877 +0# +#1878 +1# +b00000000000000000000001110101011 $ +#1879 +0# +#1880 +1# +b00000000000000000000001110101100 $ +#1881 +0# +#1882 +1# +b00000000000000000000001110101101 $ +#1883 +0# +#1884 +1# +b00000000000000000000001110101110 $ +#1885 +0# +#1886 +1# +b00000000000000000000001110101111 $ +#1887 +0# +#1888 +1# +b00000000000000000000001110110000 $ +#1889 +0# +#1890 +1# +b00000000000000000000001110110001 $ +#1891 +0# +#1892 +1# +b00000000000000000000001110110010 $ +#1893 +0# +#1894 +1# +b00000000000000000000001110110011 $ +#1895 +0# +#1896 +1# +b00000000000000000000001110110100 $ +#1897 +0# +#1898 +1# +b00000000000000000000001110110101 $ +#1899 +0# diff --git a/test_regress/t/t_trace_rollover.pl b/test_regress/t/t_trace_rollover.pl new file mode 100755 index 000000000..ea462b851 --- /dev/null +++ b/test_regress/t/t_trace_rollover.pl @@ -0,0 +1,36 @@ +#!/usr/bin/env perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2003-2013 by Wilson Snyder. This program is free software; you +# can redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +scenarios(vlt_all => 1); + +top_filename("t_trace_cat.v"); + +compile( + make_top_shell => 0, + make_main => 0, + v_flags2 => ["--trace --exe $Self->{t_dir}/t_trace_rollover.cpp"], + ); + +execute( + check_finished => 1, + ); + +system("cat $Self->{obj_dir}/simrollover_cat*.vcd " + . " > $Self->{obj_dir}/simall.vcd"); + +vcd_identical("$Self->{obj_dir}/simall.vcd", + $Self->{golden_filename}); + +file_grep_not("$Self->{obj_dir}/simrollover_cat0000.vcd", qr/^#/i); +file_grep("$Self->{obj_dir}/simrollover_cat0001.vcd", qr/^#/i); +file_grep("$Self->{obj_dir}/simrollover_cat0002.vcd", qr/^#/i); + +ok(1); +1; From 0a3a15a66ee4f7fed966ae86019dc7047585bc06 Mon Sep 17 00:00:00 2001 From: Arkadiusz Kozdra Date: Sun, 28 Aug 2022 16:24:55 +0200 Subject: [PATCH 4/9] Support class parameters (#2231) (#3541) --- src/V3AstNodes.h | 3 +- src/V3Common.cpp | 2 +- src/V3Const.cpp | 1 + src/V3LinkCells.cpp | 3 - src/V3LinkDot.cpp | 39 +++- src/V3Param.cpp | 228 +++++++++++--------- src/V3Width.cpp | 11 + test_regress/t/t_class_param.out | 30 --- test_regress/t/t_class_param.pl | 4 +- test_regress/t/t_class_param.v | 14 ++ test_regress/t/t_class_param_circ_bad.out | 5 + test_regress/t/t_class_param_circ_bad.pl | 19 ++ test_regress/t/t_class_param_circ_bad.v | 21 ++ test_regress/t/t_class_param_extends.pl | 21 ++ test_regress/t/t_class_param_extends.v | 52 +++++ test_regress/t/t_class_param_mod.pl | 3 +- test_regress/t/t_class_param_mod.v | 14 ++ test_regress/t/t_class_param_nconst_bad.out | 13 +- test_regress/t/t_class_param_nested_bad.out | 10 + test_regress/t/t_class_param_nested_bad.pl | 19 ++ test_regress/t/t_class_param_nested_bad.v | 64 ++++++ test_regress/t/t_class_param_pkg.out | 30 --- test_regress/t/t_class_param_pkg.pl | 4 +- test_regress/t/t_class_param_pkg.v | 14 ++ test_regress/t/t_class_vparam.out | 18 -- test_regress/t/t_class_vparam.pl | 4 +- test_regress/t/t_class_vparam.v | 14 +- 27 files changed, 449 insertions(+), 211 deletions(-) delete mode 100644 test_regress/t/t_class_param.out create mode 100644 test_regress/t/t_class_param_circ_bad.out create mode 100755 test_regress/t/t_class_param_circ_bad.pl create mode 100644 test_regress/t/t_class_param_circ_bad.v create mode 100755 test_regress/t/t_class_param_extends.pl create mode 100644 test_regress/t/t_class_param_extends.v create mode 100644 test_regress/t/t_class_param_nested_bad.out create mode 100755 test_regress/t/t_class_param_nested_bad.pl create mode 100644 test_regress/t/t_class_param_nested_bad.v delete mode 100644 test_regress/t/t_class_param_pkg.out delete mode 100644 test_regress/t/t_class_vparam.out diff --git a/src/V3AstNodes.h b/src/V3AstNodes.h index a6ebe193e..64c25e494 100644 --- a/src/V3AstNodes.h +++ b/src/V3AstNodes.h @@ -3235,8 +3235,7 @@ public: AstNodeModule* classOrPackagep() const { AstNode* foundp = m_classOrPackageNodep; while (auto* const anodep = VN_CAST(foundp, Typedef)) foundp = anodep->subDTypep(); - while (auto* const anodep = VN_CAST(foundp, ClassRefDType)) - foundp = anodep->classOrPackagep(); + if (auto* const anodep = VN_CAST(foundp, ClassRefDType)) foundp = anodep->classp(); return VN_CAST(foundp, NodeModule); } AstPackage* packagep() const { return VN_CAST(classOrPackageNodep(), Package); } diff --git a/src/V3Common.cpp b/src/V3Common.cpp index ad4ecaf6e..6f983809c 100644 --- a/src/V3Common.cpp +++ b/src/V3Common.cpp @@ -86,7 +86,7 @@ static void makeToStringMiddle(AstClass* nodep) { } } } - if (nodep->extendsp() && nodep->extendsp()->classp()->user1()) { + if (nodep->extendsp()) { string stmt = "out += "; if (!comma.empty()) stmt += "\", \"+ "; // comma = ", "; // Nothing further so not needed diff --git a/src/V3Const.cpp b/src/V3Const.cpp index fc4555304..fb90cf866 100644 --- a/src/V3Const.cpp +++ b/src/V3Const.cpp @@ -2379,6 +2379,7 @@ private: iterateChildren(nodep); } } + virtual void visit(AstClassOrPackageRef* nodep) override { iterateChildren(nodep); } virtual void visit(AstPin* nodep) override { iterateChildren(nodep); } void replaceLogEq(AstLogEq* nodep) { diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp index ec0da2f09..03703c2c8 100644 --- a/src/V3LinkCells.cpp +++ b/src/V3LinkCells.cpp @@ -471,9 +471,6 @@ private: } } - // Accelerate the recursion - // Must do statements to support Generates, math though... - virtual void visit(AstNodeMath*) override {} virtual void visit(AstNode* nodep) override { iterateChildren(nodep); } // METHODS diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp index 45e5a2038..f5dc1b59e 100644 --- a/src/V3LinkDot.cpp +++ b/src/V3LinkDot.cpp @@ -1988,6 +1988,16 @@ private: } } + bool isParamedClassRef(const AstNode* nodep) { + if (const auto* classRefp = VN_CAST(nodep, ClassOrPackageRef)) { + if (classRefp->paramsp()) return true; + const auto* classp = classRefp->classOrPackageNodep(); + while (const auto* typedefp = VN_CAST(classp, Typedef)) classp = typedefp->subDTypep(); + return VN_IS(classp, ClassRefDType) && VN_AS(classp, ClassRefDType)->paramsp(); + } + return false; + } + // VISITs virtual void visit(AstNetlist* nodep) override { // Recurse..., backward as must do packages before using packages @@ -2172,11 +2182,17 @@ private: // if (!start) { nodep->lhsp()->v3error("Package reference may not be embedded in // dotted reference"); m_ds.m_dotErr=true; } m_ds.m_dotPos = DP_PACKAGE; + iterateAndNextNull(nodep->lhsp()); } else { m_ds.m_dotPos = DP_SCOPE; iterateAndNextNull(nodep->lhsp()); // if (debug() >= 9) nodep->dumpTree("-dot-lho: "); } + if (m_statep->forPrimary() && isParamedClassRef(nodep->lhsp())) { + // Dots of paramed classes will be linked after deparametrization + m_ds.m_dotPos = DP_NONE; + return; + } if (m_ds.m_unresolved && (VN_IS(nodep->lhsp(), CellRef) || VN_IS(nodep->lhsp(), CellArrayRef))) { m_ds.m_unlinkedScopep = nodep->lhsp(); @@ -2517,13 +2533,24 @@ private: if (start) m_ds = lastStates; } virtual void visit(AstClassOrPackageRef* nodep) override { - UINFO(9, " linkClassOrPackageRef " << m_ds.ascii() << " n=" << nodep << endl); - if (m_ds.m_dotPos == DP_PACKAGE) { - // Already under dot, so this is {ClassOrPackage} Dot {ClassOrPackage} - // m_ds.m_dotText communicates the cell prefix between stages - m_ds.m_dotPos = DP_PACKAGE; + // Class: Recurse inside or cleanup not founds + // checkNoDot not appropriate, can be under a dot + AstNode::user5ClearTree(); + UASSERT_OBJ(m_statep->forPrimary() || nodep->classOrPackagep(), nodep, + "ClassRef has unlinked class"); + UASSERT_OBJ(m_statep->forPrimary() || !nodep->paramsp(), nodep, + "class reference parameter not removed by V3Param"); + VL_RESTORER(m_ds); + VL_RESTORER(m_pinSymp); + { + // ClassRef's have pins, so track + if (nodep->classOrPackagep()) { + m_pinSymp = m_statep->getNodeSym(nodep->classOrPackagep()); + } + m_ds.init(m_curSymp); + UINFO(4, "(Backto) Link ClassOrPackageRef: " << nodep << endl); + iterateChildren(nodep); } - // TODO we don't iterate pins yet, as class parameters are not supported } virtual void visit(AstVarRef* nodep) override { diff --git a/src/V3Param.cpp b/src/V3Param.cpp index 62aa66541..8c1595194 100644 --- a/src/V3Param.cpp +++ b/src/V3Param.cpp @@ -557,15 +557,16 @@ class ParamProcessor final { if ((newmodp->level() - srcModp->level()) >= (v3Global.opt.moduleRecursionDepth() - 2)) { cellp->v3error("Exceeded maximum --module-recursion-depth of " << v3Global.opt.moduleRecursionDepth()); + return; } // Keep tree sorted by level. Note: Different parametrizations of the same recursive module // end up with the same level, which we will need to fix up at the end, as we do not know // up front how recursive modules are expanded, and a later expansion might re-use an // earlier expansion (see t_recursive_module_bug_2). - AstNodeModule* insertp = srcModp; - while (insertp->nextp() + AstNode* insertp = srcModp; + while (VN_IS(insertp->nextp(), NodeModule) && VN_AS(insertp->nextp(), NodeModule)->level() <= newmodp->level()) { - insertp = VN_AS(insertp->nextp(), NodeModule); + insertp = insertp->nextp(); } insertp->addNextHere(newmodp); @@ -699,9 +700,9 @@ class ParamProcessor final { } } - void cellInterfaceCleanup(AstCell* nodep, AstNodeModule* srcModp, string& longnamer, + void cellInterfaceCleanup(AstPin* pinsp, AstNodeModule* srcModp, string& longnamer, bool& any_overridesr, IfaceRefRefs& ifaceRefRefs) { - for (AstPin* pinp = nodep->pinsp(); pinp; pinp = VN_AS(pinp->nextp(), Pin)) { + for (AstPin* pinp = pinsp; pinp; pinp = VN_AS(pinp->nextp(), Pin)) { const AstVar* const modvarp = pinp->modVarp(); if (modvarp->isIfaceRef()) { AstIfaceRefDType* portIrefp = VN_CAST(modvarp->subDTypep(), IfaceRefDType); @@ -761,8 +762,73 @@ class ParamProcessor final { } } + bool nodeDeparamCommon(AstNode* nodep, AstNodeModule*& srcModpr, AstPin* paramsp, + AstPin* pinsp, bool any_overrides) { + // Make sure constification worked + // Must be a separate loop, as constant conversion may have changed some pointers. + // if (debug()) nodep->dumpTree(cout, "-cel2: "); + string longname = srcModpr->name() + "_"; + if (debug() > 8 && paramsp) paramsp->dumpTreeAndNext(cout, "-cellparams: "); + + if (srcModpr->hierBlock()) { + longname = parameterizedHierBlockName(srcModpr, paramsp); + any_overrides = longname != srcModpr->name(); + } else { + for (AstPin* pinp = paramsp; pinp; pinp = VN_AS(pinp->nextp(), Pin)) { + cellPinCleanup(nodep, pinp, srcModpr, longname /*ref*/, any_overrides /*ref*/); + } + } + IfaceRefRefs ifaceRefRefs; + cellInterfaceCleanup(pinsp, srcModpr, longname /*ref*/, any_overrides /*ref*/, + ifaceRefRefs /*ref*/); + + if (!any_overrides) { + UINFO(8, "Cell parameters all match original values, skipping expansion.\n"); + } else if (AstNodeModule* const paramedModp + = m_hierBlocks.findByParams(srcModpr->name(), paramsp, m_modp)) { + paramedModp->dead(false); + // We need to relink the pins to the new module + relinkPinsByName(pinsp, paramedModp); + srcModpr = paramedModp; + } else { + const string newname + = srcModpr->hierBlock() ? longname : moduleCalcName(srcModpr, longname); + const ModInfo* const modInfop + = moduleFindOrClone(srcModpr, nodep, paramsp, newname, ifaceRefRefs); + // We need to relink the pins to the new module + relinkPinsByName(pinsp, modInfop->m_modp); + UINFO(8, " Done with " << modInfop->m_modp << endl); + srcModpr = modInfop->m_modp; + } + + // Delete the parameters from the cell; they're not relevant any longer. + if (paramsp) paramsp->unlinkFrBackWithNext()->deleteTree(); + return any_overrides; + } + + void cellDeparam(AstCell* nodep, AstNodeModule*& srcModpr) { + // Must always clone __Vrcm (recursive modules) + if (nodeDeparamCommon(nodep, srcModpr, nodep->paramsp(), nodep->pinsp(), + nodep->recursive())) { + nodep->modp(srcModpr); + nodep->modName(srcModpr->name()); + } + nodep->recursive(false); + } + + void classRefDeparam(AstClassOrPackageRef* nodep, AstNodeModule*& srcModpr) { + if (nodeDeparamCommon(nodep, srcModpr, nodep->paramsp(), nullptr, false)) + nodep->classOrPackagep(srcModpr); + } + + void classRefDeparam(AstClassRefDType* nodep, AstNodeModule*& srcModpr) { + if (nodeDeparamCommon(nodep, srcModpr, nodep->paramsp(), nullptr, false)) + nodep->classp(VN_AS(srcModpr, Class)); + } + public: - void cellDeparam(AstCell* nodep, AstNodeModule* modp, const string& someInstanceName) { + void nodeDeparam(AstNode* nodep, AstNodeModule*& srcModpr, AstNodeModule* modp, + const string& someInstanceName) { m_modp = modp; // Cell: Check for parameters in the instantiation. // We always run this, even if no parameters, as need to look for interfaces, @@ -772,57 +838,18 @@ public: if (debug() >= 10) nodep->dumpTree(cout, "-cell: "); // Evaluate all module constants V3Const::constifyParamsEdit(nodep); - AstNodeModule* const srcModp = nodep->modp(); - srcModp->someInstanceName(someInstanceName + "." + nodep->name()); + srcModpr->someInstanceName(someInstanceName + "." + nodep->name()); - // Make sure constification worked - // Must be a separate loop, as constant conversion may have changed some pointers. - // if (debug()) nodep->dumpTree(cout, "-cel2: "); - string longname = srcModp->name() + "_"; - bool any_overrides = false; - // Must always clone __Vrcm (recursive modules) - if (nodep->recursive()) any_overrides = true; - if (debug() > 8 && nodep->paramsp()) - nodep->paramsp()->dumpTreeAndNext(cout, "-cellparams: "); - - if (srcModp->hierBlock()) { - longname = parameterizedHierBlockName(srcModp, nodep->paramsp()); - any_overrides = longname != srcModp->name(); + if (auto* cellp = VN_CAST(nodep, Cell)) { + cellDeparam(cellp, srcModpr); + } else if (auto* classRefp = VN_CAST(nodep, ClassRefDType)) { + classRefDeparam(classRefp, srcModpr); + } else if (auto* classRefp = VN_CAST(nodep, ClassOrPackageRef)) { + classRefDeparam(classRefp, srcModpr); } else { - for (AstPin* pinp = nodep->paramsp(); pinp; pinp = VN_AS(pinp->nextp(), Pin)) { - cellPinCleanup(nodep, pinp, srcModp, longname /*ref*/, any_overrides /*ref*/); - } - } - IfaceRefRefs ifaceRefRefs; - cellInterfaceCleanup(nodep, srcModp, longname /*ref*/, any_overrides /*ref*/, - ifaceRefRefs /*ref*/); - - if (!any_overrides) { - UINFO(8, "Cell parameters all match original values, skipping expansion.\n"); - } else if (AstNodeModule* const paramedModp - = m_hierBlocks.findByParams(srcModp->name(), nodep->paramsp(), m_modp)) { - nodep->modp(paramedModp); - nodep->modName(paramedModp->name()); - paramedModp->dead(false); - // We need to relink the pins to the new module - relinkPinsByName(nodep->pinsp(), paramedModp); - } else { - const string newname - = srcModp->hierBlock() ? longname : moduleCalcName(srcModp, longname); - const ModInfo* const modInfop - = moduleFindOrClone(srcModp, nodep, nodep->paramsp(), newname, ifaceRefRefs); - // Have child use this module instead. - nodep->modp(modInfop->m_modp); - nodep->modName(newname); - // We need to relink the pins to the new module - relinkPinsByName(nodep->pinsp(), modInfop->m_modp); - UINFO(8, " Done with " << modInfop->m_modp << endl); + nodep->v3fatalSrc("Expected module parametrization"); } - nodep->recursive(false); - - // Delete the parameters from the cell; they're not relevant any longer. - if (nodep->paramsp()) nodep->paramsp()->unlinkFrBackWithNext()->deleteTree(); UINFO(8, " Done with " << nodep << endl); // if (debug() >= 10) // v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("param-out.tree")); @@ -854,7 +881,8 @@ class ParamVisitor final : public VNVisitor { bool m_iterateModule = false; // Iterating module body string m_generateHierName; // Generate portion of hierarchy name string m_unlinkedTxt; // Text for AstUnlinkedRef - std::deque m_cellps; // Cells left to process (in current module) + std::multimap m_cellps; // Cells left to process (in current module) + std::multimap m_workQueue; // Modules left to process // Map from AstNodeModule to set of all AstNodeModules that instantiates it. std::unordered_map> m_parentps; @@ -887,32 +915,40 @@ class ParamVisitor final : public VNVisitor { // Process interface cells, then non-interface cells, which may reference an interface // cell. - for (bool doInterface : {true, false}) { - for (AstCell* const cellp : m_cellps) { - if (doInterface != VN_IS(cellp->modp(), Iface)) continue; + while (!m_cellps.empty()) { + const auto itm = m_cellps.cbegin(); + AstNode* const cellp = itm->second; + m_cellps.erase(itm); - // Visit parameters in the instantiation. - iterateChildren(cellp); - - // Update path - string someInstanceName(modp->someInstanceName()); - if (const string* const genHierNamep = cellp->user5u().to()) { - someInstanceName += *genHierNamep; - cellp->user5p(nullptr); - VL_DO_DANGLING(delete genHierNamep, genHierNamep); - } - - // Apply parameter specialization - m_processor.cellDeparam(cellp, modp, someInstanceName); - - // Add the (now potentially specialized) child module to the work queue - workQueue.emplace(cellp->modp()->level(), cellp->modp()); - - // Add to the hierarchy registry - m_parentps[cellp->modp()].insert(modp); + AstNodeModule* srcModp = nullptr; + if (const auto* modCellp = VN_CAST(cellp, Cell)) { + srcModp = modCellp->modp(); + } else if (const auto* classRefp = VN_CAST(cellp, ClassOrPackageRef)) { + srcModp = classRefp->classOrPackagep(); + } else if (const auto* classRefp = VN_CAST(cellp, ClassRefDType)) { + srcModp = classRefp->classp(); + } else { + cellp->v3fatalSrc("Expected module parametrization"); } + + // Update path + string someInstanceName(modp->someInstanceName()); + if (const string* const genHierNamep = cellp->user5u().to()) { + someInstanceName += *genHierNamep; + cellp->user5p(nullptr); + VL_DO_DANGLING(delete genHierNamep, genHierNamep); + } + + // Apply parameter specialization + m_processor.nodeDeparam(cellp, srcModp /* ref */, modp, someInstanceName); + + // Add the (now potentially specialized) child module to the work queue + workQueue.emplace(srcModp->level(), srcModp); + + // Add to the hierarchy registry + m_parentps[srcModp].insert(modp); } - m_cellps.clear(); + if (workQueue.empty()) std::swap(workQueue, m_workQueue); } while (!workQueue.empty()); m_iterateModule = false; @@ -930,25 +966,24 @@ class ParamVisitor final : public VNVisitor { if (modp->level() <= maxParentLevel) modp->level(maxParentLevel + 1); } + // A generic visitor for cells and class refs + void visitCellOrClassRef(AstNode* nodep, bool isIface) { + // Must do ifaces first, so push to list and do in proper order + string* const genHierNamep = new string{m_generateHierName}; + nodep->user5p(genHierNamep); + // Visit parameters in the instantiation. + iterateChildren(nodep); + m_cellps.emplace(!isIface, nodep); + } + // VISITORS virtual void visit(AstNodeModule* nodep) override { if (nodep->recursiveClone()) nodep->dead(true); // Fake, made for recursive elimination if (nodep->dead()) return; // Marked by LinkDot (and above) - // Warn on unsupported parametrised class - if (VN_IS(nodep, Class)) { - for (AstNode* stmtp = nodep->stmtsp(); stmtp; stmtp = stmtp->nextp()) { - if (const AstVar* const varp = VN_CAST(stmtp, Var)) { - if (varp->isParam()) { - varp->v3warn(E_UNSUPPORTED, "Unsupported: class parameters"); - } - } - } - } - if (m_iterateModule) { // Iterating body UINFO(4, " MOD-under-MOD. " << nodep << endl); - iterateChildren(nodep); + m_workQueue.emplace(nodep->level(), nodep); // Delay until current module is done return; } @@ -961,19 +996,10 @@ class ParamVisitor final : public VNVisitor { } virtual void visit(AstCell* nodep) override { - // Must do ifaces first, so push to list and do in proper order - string* const genHierNamep = new string(m_generateHierName); - nodep->user5p(genHierNamep); - m_cellps.push_back(nodep); - } - - virtual void visit(AstClassRefDType* nodep) override { - if (nodep->paramsp()) { - nodep->paramsp()->v3warn(E_UNSUPPORTED, "Unsupported: parameterized classes"); - pushDeletep(nodep->paramsp()->unlinkFrBackWithNext()); - } - iterateChildren(nodep); + visitCellOrClassRef(nodep, VN_IS(nodep->modp(), Iface)); } + virtual void visit(AstClassRefDType* nodep) override { visitCellOrClassRef(nodep, false); } + virtual void visit(AstClassOrPackageRef* nodep) override { visitCellOrClassRef(nodep, false); } // Make sure all parameters are constantified virtual void visit(AstVar* nodep) override { diff --git a/src/V3Width.cpp b/src/V3Width.cpp index 824d66beb..a9f784e06 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -2438,6 +2438,17 @@ private: // though causes problems with t_class_forward.v, so for now avoided // userIterateChildren(nodep->classp(), nullptr); } + virtual void visit(AstClassOrPackageRef* nodep) override { + if (nodep->didWidthAndSet()) return; + userIterateChildren(nodep, nullptr); + } + virtual void visit(AstDot* nodep) override { + // We can only reach this from constify called during V3Param (so before linkDotParam) + // ... #(Cls#(...)::...) ... + // ^^~~~ this is our DOT + nodep->v3warn(E_UNSUPPORTED, "dotted expressions in parameters\n" + << nodep->warnMore() << "... Suggest use a typedef"); + } virtual void visit(AstClassExtends* nodep) override { if (nodep->didWidthAndSet()) return; if (VN_IS(nodep->childDTypep(), ClassRefDType)) { diff --git a/test_regress/t/t_class_param.out b/test_regress/t/t_class_param.out deleted file mode 100644 index 442cfc01e..000000000 --- a/test_regress/t/t_class_param.out +++ /dev/null @@ -1,30 +0,0 @@ -%Error-UNSUPPORTED: t/t_class_param.v:40:11: Unsupported: parameterized classes - : ... In instance t - 40 | Cls #(.PBASE(4)) c4; - | ^~~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest -%Error-UNSUPPORTED: t/t_class_param.v:42:12: Unsupported: parameterized classes - : ... In instance t - 42 | Wrap #(.P(16)) w16; - | ^ -%Error-UNSUPPORTED: t/t_class_param.v:13:24: Unsupported: class parameters - : ... In instance t - 13 | class Wrap #(parameter P = 13); - | ^ -%Error-UNSUPPORTED: t/t_class_param.v:21:15: Unsupported: class parameters - : ... In instance t - 21 | localparam PMINUS1 = P - 1; - | ^~~~~~~ -%Error-UNSUPPORTED: t/t_class_param.v:20:17: Unsupported: parameterized classes - : ... In instance t - 20 | Cls#(PMINUS1 + 1) c1; - | ^ -%Error-UNSUPPORTED: t/t_class_param.v:24:23: Unsupported: class parameters - : ... In instance t - 24 | class Cls #(parameter PBASE = 12); - | ^~~~~ -%Error-UNSUPPORTED: t/t_class_param.v:35:14: Unsupported: parameterized classes - : ... In instance t - 35 | typedef Cls#(8) Cls8_t; - | ^ -%Error: Exiting due to diff --git a/test_regress/t/t_class_param.pl b/test_regress/t/t_class_param.pl index 2ad4a887d..aabcde63e 100755 --- a/test_regress/t/t_class_param.pl +++ b/test_regress/t/t_class_param.pl @@ -11,13 +11,11 @@ if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); di scenarios(simulator => 1); compile( - fails => $Self->{vlt_all}, - expect_filename => $Self->{golden_filename}, ); execute( check_finished => 1, - ) if !$Self->{vlt_all}; + ); ok(1); 1; diff --git a/test_regress/t/t_class_param.v b/test_regress/t/t_class_param.v index 0fc61cb76..99740abb7 100644 --- a/test_regress/t/t_class_param.v +++ b/test_regress/t/t_class_param.v @@ -21,6 +21,17 @@ class Wrap #(parameter P = 13); localparam PMINUS1 = P - 1; // Checking works when last endclass +class Wrap2 #(parameter P = 35); + function int get_p; + return c1.get_p(); + endfunction + function new; + c1 = new; + endfunction + Wrap#(PMINUS1 + 1) c1; + localparam PMINUS1 = P - 1; // Checking works when last +endclass + class Cls #(parameter PBASE = 12); bit [PBASE-1:0] member; function bit [PBASE-1:0] get_member; @@ -40,11 +51,13 @@ module t (/*AUTOARG*/); Cls #(.PBASE(4)) c4; Cls8_t c8; Wrap #(.P(16)) w16; + Wrap2 #(.P(32)) w32; initial begin c12 = new; c4 = new; c8 = new; w16 = new; + w32 = new; if (Cls#()::PBASE != 12) $stop; if (Cls#(4)::PBASE != 4) $stop; if (Cls8_t::PBASE != 8) $stop; @@ -65,6 +78,7 @@ module t (/*AUTOARG*/); if (c4.get_p() != 4) $stop; if (c8.get_p() != 8) $stop; if (w16.get_p() != 16) $stop; + if (w32.get_p() != 32) $stop; // verilator lint_off WIDTH c12.member = 32'haaaaaaaa; diff --git a/test_regress/t/t_class_param_circ_bad.out b/test_regress/t/t_class_param_circ_bad.out new file mode 100644 index 000000000..35b6ce09a --- /dev/null +++ b/test_regress/t/t_class_param_circ_bad.out @@ -0,0 +1,5 @@ +%Error: t/t_class_param_circ_bad.v:14:4: Exceeded maximum --module-recursion-depth of 100 + : ... In instance t + 14 | ClsA #(PARAM+1) a; + | ^~~~ +%Error: Internal Error: ../V3Param.cpp:#: should find just-made module diff --git a/test_regress/t/t_class_param_circ_bad.pl b/test_regress/t/t_class_param_circ_bad.pl new file mode 100755 index 000000000..c35c8bc93 --- /dev/null +++ b/test_regress/t/t_class_param_circ_bad.pl @@ -0,0 +1,19 @@ +#!/usr/bin/env perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2022 by Wilson Snyder. This program is free software; you +# can redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +scenarios(simulator => 1); + +lint( + fails => 1, + expect_filename => $Self->{golden_filename}, + ); + +ok(1); +1; diff --git a/test_regress/t/t_class_param_circ_bad.v b/test_regress/t/t_class_param_circ_bad.v new file mode 100644 index 000000000..3ebe10df8 --- /dev/null +++ b/test_regress/t/t_class_param_circ_bad.v @@ -0,0 +1,21 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed under the Creative Commons Public Domain, for +// any use, without warranty, 2022 by Wilson Snyder. +// SPDX-License-Identifier: CC0-1.0 + +typedef class ClsB; + +class ClsA #(parameter PARAM = 12); + ClsB #(PARAM+1) b; +endclass + +class ClsB #(parameter PARAM = 12); + ClsA #(PARAM+1) a; +endclass + +module t (/*AUTOARG*/); + + ClsA #(.PARAM(15)) c; // Bad param name + +endmodule diff --git a/test_regress/t/t_class_param_extends.pl b/test_regress/t/t_class_param_extends.pl new file mode 100755 index 000000000..1aa73f80a --- /dev/null +++ b/test_regress/t/t_class_param_extends.pl @@ -0,0 +1,21 @@ +#!/usr/bin/env perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2022 by Wilson Snyder. This program is free software; you +# can redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +scenarios(simulator => 1); + +compile( + ); + +execute( + check_finished => 1, + ); + +ok(1); +1; diff --git a/test_regress/t/t_class_param_extends.v b/test_regress/t/t_class_param_extends.v new file mode 100644 index 000000000..1c1078ea7 --- /dev/null +++ b/test_regress/t/t_class_param_extends.v @@ -0,0 +1,52 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed under the Creative Commons Public Domain, for +// any use, without warranty, 2022 by Wilson Snyder. +// SPDX-License-Identifier: CC0-1.0 + +// Code your testbench here +// or browse Examples +class Base #(parameter PBASE = 12); + bit [PBASE-1:0] member; + function bit [PBASE-1:0] get_member; + return member; + endfunction + function int get_p; + return PBASE; + endfunction +endclass + +class Cls #(parameter P = 13) extends Base #(P); +endclass + +typedef Cls#(8) Cls8_t; + +// See also t_class_param_mod.v + +module t (/*AUTOARG*/); + + Cls #(.P(4)) c4; + Cls8_t c8; + + initial begin + c4 = new; + c8 = new; + if (c4.PBASE != 4) $stop; + if (c8.PBASE != 8) $stop; + if (c4.get_p() != 4) $stop; + if (c8.get_p() != 8) $stop; + // verilator lint_off WIDTH + c4.member = 32'haaaaaaaa; + c8.member = 32'haaaaaaaa; + // verilator lint_on WIDTH + if (c4.member != 4'ha) $stop; + if (c4.get_member() != 4'ha) $stop; + if (c8.member != 8'haa) $stop; + if (c8.get_member() != 8'haa) $stop; + $display("c4 = %s", $sformatf("%p", c4)); + if ($sformatf("%p", c4) != "'{member:'ha}") $stop; + + $write("*-* All Finished *-*\n"); + $finish; + end +endmodule diff --git a/test_regress/t/t_class_param_mod.pl b/test_regress/t/t_class_param_mod.pl index a2ed99042..aabcde63e 100755 --- a/test_regress/t/t_class_param_mod.pl +++ b/test_regress/t/t_class_param_mod.pl @@ -11,12 +11,11 @@ if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); di scenarios(simulator => 1); compile( - fails => $Self->{vlt_all}, ); execute( check_finished => 1, - ) if !$Self->{vlt_all}; + ); ok(1); 1; diff --git a/test_regress/t/t_class_param_mod.v b/test_regress/t/t_class_param_mod.v index 67065e2d7..a57ba7316 100644 --- a/test_regress/t/t_class_param_mod.v +++ b/test_regress/t/t_class_param_mod.v @@ -32,17 +32,30 @@ class Wrap #(parameter P = 13); localparam PMINUS1 = P - 1; // Checking works when last endclass +class Wrap2 #(parameter P = 35); + function int get_p; + return c1.get_p(); + endfunction + function new; + c1 = new; + endfunction + Wrap#(PMINUS1 + 1) c1; + localparam PMINUS1 = P - 1; // Checking works when last +endclass + typedef Cls#(8) Cls8_t; Cls c12; Cls #(.PBASE(4)) c4; Cls8_t c8; Wrap #(.P(16)) w16; + Wrap2 #(.P(32)) w32; initial begin c12 = new; c4 = new; c8 = new; w16 = new; + w32 = new; if (Cls#()::PBASE != 12) $stop; if (Cls#(4)::PBASE != 4) $stop; if (Cls8_t::PBASE != 8) $stop; @@ -63,6 +76,7 @@ endclass if (c4.get_p() != 4) $stop; if (c8.get_p() != 8) $stop; if (w16.get_p() != 16) $stop; + if (w32.get_p() != 32) $stop; // verilator lint_off WIDTH c12.member = 32'haaaaaaaa; diff --git a/test_regress/t/t_class_param_nconst_bad.out b/test_regress/t/t_class_param_nconst_bad.out index 100f930d8..812399530 100644 --- a/test_regress/t/t_class_param_nconst_bad.out +++ b/test_regress/t/t_class_param_nconst_bad.out @@ -1,10 +1,9 @@ -%Error-UNSUPPORTED: t/t_class_param_nconst_bad.v:12:11: Unsupported: parameterized classes - : ... In instance t +%Error: t/t_class_param_nconst_bad.v:12:17: Expecting expression to be constant, but can't convert a RAND to constant. + : ... In instance t + 12 | Cls #(.PARAM($random)) c; + | ^~~~~~~ +%Error: t/t_class_param_nconst_bad.v:12:11: Can't convert defparam value to constant: Param 'PARAM' of 'Cls' + : ... In instance t 12 | Cls #(.PARAM($random)) c; | ^~~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest -%Error-UNSUPPORTED: t/t_class_param_nconst_bad.v:7:23: Unsupported: class parameters - : ... In instance t - 7 | class Cls #(parameter PARAM = 12); - | ^~~~~ %Error: Exiting due to diff --git a/test_regress/t/t_class_param_nested_bad.out b/test_regress/t/t_class_param_nested_bad.out new file mode 100644 index 000000000..ce4a30bc0 --- /dev/null +++ b/test_regress/t/t_class_param_nested_bad.out @@ -0,0 +1,10 @@ +%Error-UNSUPPORTED: t/t_class_param_nested_bad.v:51:23: dotted expressions in parameters + : ... In instance t + : ... Suggest use a typedef + 51 | Wrap2 #(Wrap#(19)::PBASE * 2) w38; + | ^~~~~ + ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest +%Error: Internal Error: t/t_class_param_nested_bad.v:51:29: ../V3Width.cpp:#: Node has no type + : ... In instance t + 51 | Wrap2 #(Wrap#(19)::PBASE * 2) w38; + | ^ diff --git a/test_regress/t/t_class_param_nested_bad.pl b/test_regress/t/t_class_param_nested_bad.pl new file mode 100755 index 000000000..c35c8bc93 --- /dev/null +++ b/test_regress/t/t_class_param_nested_bad.pl @@ -0,0 +1,19 @@ +#!/usr/bin/env perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2022 by Wilson Snyder. This program is free software; you +# can redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +scenarios(simulator => 1); + +lint( + fails => 1, + expect_filename => $Self->{golden_filename}, + ); + +ok(1); +1; diff --git a/test_regress/t/t_class_param_nested_bad.v b/test_regress/t/t_class_param_nested_bad.v new file mode 100644 index 000000000..ec65b3e09 --- /dev/null +++ b/test_regress/t/t_class_param_nested_bad.v @@ -0,0 +1,64 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed under the Creative Commons Public Domain, for +// any use, without warranty, 2022 by Arkadiusz Kozdra. +// SPDX-License-Identifier: CC0-1.0 + +typedef class Cls; + +class Wrap #(parameter P = 13); + function int get_p; + return c1.get_p(); + endfunction + function new; + c1 = new; + endfunction + Cls#(PMINUS1 + 1) c1; + localparam PMINUS1 = P - 1; // Checking works when last +endclass + +class Wrap2 #(parameter P = 35); + function int get_p; + return c1.get_p(); + endfunction + function new; + c1 = new; + endfunction + Wrap#(PMINUS1 + 1) c1; + localparam PMINUS1 = P - 1; // Checking works when last +endclass + +class Cls #(parameter PBASE = 12); + bit [PBASE-1:0] member; + function bit [PBASE-1:0] get_member; + return member; + endfunction + static function int get_p; + return PBASE; + endfunction + typedef enum { E_PBASE = PBASE } enum_t; +endclass + +typedef Cls#(8) Cls8_t; + +module t (/*AUTOARG*/); + + Cls c12; + Cls #(.PBASE(4)) c4; + Cls8_t c8; + Wrap #(.P(16)) w16; + Wrap2 #(.P(32)) w32; + Wrap2 #(Wrap#(19)::PBASE * 2) w38; + initial begin + c12 = new; + c4 = new; + c8 = new; + w16 = new; + w32 = new; + w38 = new; + if (w38.get_p() != 38) $stop; + + $write("*-* All Finished *-*\n"); + $finish; + end +endmodule diff --git a/test_regress/t/t_class_param_pkg.out b/test_regress/t/t_class_param_pkg.out deleted file mode 100644 index a01b5aed6..000000000 --- a/test_regress/t/t_class_param_pkg.out +++ /dev/null @@ -1,30 +0,0 @@ -%Error-UNSUPPORTED: t/t_class_param_pkg.v:43:16: Unsupported: parameterized classes - : ... In instance t - 43 | Pkg::Cls #(.PBASE(4)) c4; - | ^~~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest -%Error-UNSUPPORTED: t/t_class_param_pkg.v:45:17: Unsupported: parameterized classes - : ... In instance t - 45 | Pkg::Wrap #(.P(16)) w16; - | ^ -%Error-UNSUPPORTED: t/t_class_param_pkg.v:14:27: Unsupported: class parameters - : ... In instance t - 14 | class Wrap #(parameter P = 13); - | ^ -%Error-UNSUPPORTED: t/t_class_param_pkg.v:22:18: Unsupported: class parameters - : ... In instance t - 22 | localparam PMINUS1 = P - 1; - | ^~~~~~~ -%Error-UNSUPPORTED: t/t_class_param_pkg.v:21:20: Unsupported: parameterized classes - : ... In instance t - 21 | Cls#(PMINUS1 + 1) c1; - | ^ -%Error-UNSUPPORTED: t/t_class_param_pkg.v:25:26: Unsupported: class parameters - : ... In instance t - 25 | class Cls #(parameter PBASE = 12); - | ^~~~~ -%Error-UNSUPPORTED: t/t_class_param_pkg.v:36:22: Unsupported: parameterized classes - : ... In instance t - 36 | typedef Pkg::Cls#(8) Cls8_t; - | ^ -%Error: Exiting due to diff --git a/test_regress/t/t_class_param_pkg.pl b/test_regress/t/t_class_param_pkg.pl index 2ad4a887d..aabcde63e 100755 --- a/test_regress/t/t_class_param_pkg.pl +++ b/test_regress/t/t_class_param_pkg.pl @@ -11,13 +11,11 @@ if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); di scenarios(simulator => 1); compile( - fails => $Self->{vlt_all}, - expect_filename => $Self->{golden_filename}, ); execute( check_finished => 1, - ) if !$Self->{vlt_all}; + ); ok(1); 1; diff --git a/test_regress/t/t_class_param_pkg.v b/test_regress/t/t_class_param_pkg.v index 4c53244f8..e311756c2 100644 --- a/test_regress/t/t_class_param_pkg.v +++ b/test_regress/t/t_class_param_pkg.v @@ -22,6 +22,17 @@ package Pkg; localparam PMINUS1 = P - 1; // Checking works when last endclass + class Wrap2 #(parameter P = 35); + function int get_p; + return c1.get_p(); + endfunction + function new; + c1 = new; + endfunction + Wrap#(PMINUS1 + 1) c1; + localparam PMINUS1 = P - 1; // Checking works when last + endclass + class Cls #(parameter PBASE = 12); bit [PBASE-1:0] member; function bit [PBASE-1:0] get_member; @@ -43,11 +54,13 @@ module t (/*AUTOARG*/); Pkg::Cls #(.PBASE(4)) c4; Pkg::Cls8_t c8; Pkg::Wrap #(.P(16)) w16; + Pkg::Wrap2 #(.P(32)) w32; initial begin c12 = new; c4 = new; c8 = new; w16 = new; + w32 = new; if (Pkg::Cls#()::PBASE != 12) $stop; if (Pkg::Cls#(4)::PBASE != 4) $stop; if (Pkg::Cls8_t::PBASE != 8) $stop; @@ -68,6 +81,7 @@ module t (/*AUTOARG*/); if (c4.get_p() != 4) $stop; if (c8.get_p() != 8) $stop; if (w16.get_p() != 16) $stop; + if (w32.get_p() != 32) $stop; // verilator lint_off WIDTH c12.member = 32'haaaaaaaa; diff --git a/test_regress/t/t_class_vparam.out b/test_regress/t/t_class_vparam.out deleted file mode 100644 index 7c4a4ba3d..000000000 --- a/test_regress/t/t_class_vparam.out +++ /dev/null @@ -1,18 +0,0 @@ -%Error-UNSUPPORTED: t/t_class_vparam.v:11:26: Unsupported: parameterized classes - : ... In instance t - 11 | typedef paramed_class_t#(real, 1) paramed_class_double_t; - | ^~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest -%Error-UNSUPPORTED: t/t_class_vparam.v:13:56: Unsupported: class parameters - : ... In instance t - 13 | virtual class vclass #(type CTYPE_t = arg_class_t, int I = 0); - | ^ -%Error-UNSUPPORTED: t/t_class_vparam.v:14:58: Unsupported: parameterized classes - : ... In instance t - 14 | pure virtual function void funcname(paramed_class_t #(CTYPE_t) v); - | ^~~~~~~ -%Error-UNSUPPORTED: t/t_class_vparam.v:17:46: Unsupported: class parameters - : ... In instance t - 17 | class paramed_class_t #(type TYPE = int, int I = 0); - | ^ -%Error: Exiting due to diff --git a/test_regress/t/t_class_vparam.pl b/test_regress/t/t_class_vparam.pl index c6e10f70b..c81275cdf 100755 --- a/test_regress/t/t_class_vparam.pl +++ b/test_regress/t/t_class_vparam.pl @@ -11,13 +11,11 @@ if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); di scenarios(simulator => 1); compile( - fails => $Self->{vlt_all}, - expect_filename => $Self->{golden_filename}, ); execute( check_finished => 1, - ) if !$Self->{vlt_all}; + ); ok(1); 1; diff --git a/test_regress/t/t_class_vparam.v b/test_regress/t/t_class_vparam.v index 9f19c609a..660dbb5fa 100644 --- a/test_regress/t/t_class_vparam.v +++ b/test_regress/t/t_class_vparam.v @@ -8,16 +8,18 @@ typedef class paramed_class_t; typedef class arg_class_t; -typedef paramed_class_t#(real, 1) paramed_class_double_t; +typedef paramed_class_t#(logic[3:0], 1) paramed_class_logic4_t; virtual class vclass #(type CTYPE_t = arg_class_t, int I = 0); pure virtual function void funcname(paramed_class_t #(CTYPE_t) v); endclass class paramed_class_t #(type TYPE = int, int I = 0); + TYPE memb; endclass class arg_class_t; + int ifield; endclass module t (/*AUTOARG*/ @@ -26,7 +28,15 @@ module t (/*AUTOARG*/ ); input clk; - always @ (posedge clk) begin + vclass vir; + paramed_class_t#(arg_class_t) argu; + + initial begin + argu = new; + argu.memb = new; + argu.memb.ifield = 1234; + // vir.funcname(argu); + if (argu.memb.ifield != 1234) $stop; $write("*-* All Finished *-*\n"); $finish; end From d47a37fb767f55c5e79899230d017299a2bfcb79 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Mon, 29 Aug 2022 22:15:06 -0400 Subject: [PATCH 5/9] Internals: Cleanup constructors etc. No functional change. --- src/V3EmitV.cpp | 8 ++--- src/V3File.cpp | 18 +++++----- src/V3File.h | 6 ++-- src/V3ProtectLib.cpp | 80 ++++++++++++++++++++++---------------------- 4 files changed, 56 insertions(+), 56 deletions(-) diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp index e59ecfa38..77c58d9af 100644 --- a/src/V3EmitV.cpp +++ b/src/V3EmitV.cpp @@ -739,8 +739,8 @@ class EmitVFileVisitor final : public EmitVBaseVisitor { public: EmitVFileVisitor(AstNode* nodep, V3OutFile* ofp, bool trackText, bool suppressUnknown) - : EmitVBaseVisitor{suppressUnknown, nullptr} { - m_ofp = ofp; + : EmitVBaseVisitor{suppressUnknown, nullptr} + , m_ofp{ofp} { m_trackText = trackText; iterate(nodep); } @@ -791,7 +791,7 @@ class EmitVPrefixedFormatter final : public V3OutFormatter { m_os << " "; m_os << m_prefix; } - m_column++; + ++m_column; m_os << chr; } } @@ -877,6 +877,6 @@ void V3EmitV::emitvFiles() { void V3EmitV::debugEmitV(const string& filename) { UINFO(2, __FUNCTION__ << ": " << endl); - V3OutVFile of(filename); + V3OutVFile of{filename}; { EmitVFileVisitor{v3Global.rootp(), &of, true, true}; } } diff --git a/src/V3File.cpp b/src/V3File.cpp index 63f264b57..98e4d5628 100644 --- a/src/V3File.cpp +++ b/src/V3File.cpp @@ -658,7 +658,7 @@ int V3OutFormatter::endLevels(const char* strg) { int levels = m_indentLevel; { const char* cp = strg; - while (isspace(*cp)) cp++; + while (isspace(*cp)) ++cp; switch (*cp) { case '\n': // Newlines.. No need for whitespace before it return 0; @@ -668,12 +668,12 @@ int V3OutFormatter::endLevels(const char* strg) { { // label/public/private: Deindent by 2 spaces const char* mp = cp; - for (; isalnum(*mp); mp++) {} + for (; isalnum(*mp); ++mp) {} if (mp[0] == ':' && mp[1] != ':') return (levels - m_blockIndent / 2); } } // We want "} else {" to be one level to the left of normal - for (const char* cp = strg; *cp; cp++) { + for (const char* cp = strg; *cp; ++cp) { switch (*cp) { case '}': case ')': levels -= m_blockIndent; break; @@ -704,7 +704,7 @@ void V3OutFormatter::puts(const char* strg) { } bool wordstart = true; bool equalsForBracket = false; // Looking for "= {" - for (const char* cp = strg; *cp; cp++) { + for (const char* cp = strg; *cp; ++cp) { putcNoTracking(*cp); if (isalpha(*cp)) { if (wordstart && m_lang == LA_VERILOG && tokenStart(cp)) indentInc(); @@ -712,7 +712,7 @@ void V3OutFormatter::puts(const char* strg) { } switch (*cp) { case '\n': - m_lineno++; + ++m_lineno; wordstart = true; if (cp[1] == '\0') { // Add the indent later, may be a indentInc/indentDec @@ -733,7 +733,7 @@ void V3OutFormatter::puts(const char* strg) { if (m_lang == LA_C || m_lang == LA_VERILOG) { if (cp > strg && cp[-1] == '/' && !m_inStringLiteral) { // Output ignoring contents to EOL - cp++; + ++cp; while (*cp && cp[1] && cp[1] != '\n') putcNoTracking(*cp++); if (*cp) putcNoTracking(*cp); } @@ -833,7 +833,7 @@ void V3OutFormatter::putcNoTracking(char chr) { } switch (chr) { case '\n': - m_lineno++; + ++m_lineno; m_column = 0; m_nobreak = true; break; @@ -841,9 +841,9 @@ void V3OutFormatter::putcNoTracking(char chr) { case ' ': case '(': case '|': - case '&': m_column++; break; + case '&': ++m_column; break; default: - m_column++; + ++m_column; m_nobreak = false; break; } diff --git a/src/V3File.h b/src/V3File.h index 91bfa90f9..28c49e326 100644 --- a/src/V3File.h +++ b/src/V3File.h @@ -156,9 +156,6 @@ public: puts(strg); } bool exceededWidth() const { return m_column > m_commaWidth; } - bool tokenMatch(const char* cp, const char* cmp); - bool tokenStart(const char* cp); - bool tokenEnd(const char* cp); void indentInc() { m_indentLevel += m_blockIndent; } void indentDec() { m_indentLevel -= m_blockIndent; @@ -175,6 +172,9 @@ public: static string indentSpaces(int num); // Add escaped characters to strings static string quoteNameControls(const string& namein, Language lang = LA_C); + static bool tokenMatch(const char* cp, const char* cmp); + static bool tokenStart(const char* cp); + static bool tokenEnd(const char* cp); // CALLBACKS - MUST OVERRIDE virtual void putcOutput(char chr) = 0; diff --git a/src/V3ProtectLib.cpp b/src/V3ProtectLib.cpp index 1012b25eb..0bb5db9a5 100644 --- a/src/V3ProtectLib.cpp +++ b/src/V3ProtectLib.cpp @@ -66,10 +66,10 @@ private: // VISITORS virtual void visit(AstNetlist* nodep) override { m_vfilep - = new AstVFile(nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".sv"); + = new AstVFile{nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".sv"}; nodep->addFilesp(m_vfilep); m_cfilep - = new AstCFile(nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".cpp"); + = new AstCFile{nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".cpp"}; nodep->addFilesp(m_cfilep); iterateChildren(nodep); } @@ -95,7 +95,7 @@ private: } void addComment(AstTextBlock* txtp, FileLine* fl, const string& comment) { - txtp->addNodep(new AstComment(fl, comment)); + txtp->addNodep(new AstComment{fl, comment}); } void hashComment(AstTextBlock* txtp, FileLine* fl) { @@ -132,7 +132,7 @@ private: void createSvFile(FileLine* fl, AstNodeModule* modp) { // Comments - AstTextBlock* const txtp = new AstTextBlock(fl); + AstTextBlock* const txtp = new AstTextBlock{fl}; addComment(txtp, fl, "Wrapper module for DPI protected library"); addComment(txtp, fl, "This module requires lib" + m_libName + ".a or lib" + m_libName @@ -142,7 +142,7 @@ private: " to use DPI libraries\n"); // Module declaration - m_modPortsp = new AstTextBlock(fl, "module " + m_libName + " (\n", false, true); + m_modPortsp = new AstTextBlock{fl, "module " + m_libName + " (\n", false, true}; txtp->addNodep(m_modPortsp); txtp->addText(fl, ");\n\n"); @@ -170,31 +170,31 @@ private: txtp->addText(fl, "import \"DPI-C\" function chandle " + m_libName + "_protectlib_create(string scope__V);\n\n"); comboComment(txtp, fl); - m_comboPortsp = new AstTextBlock(fl, + m_comboPortsp = new AstTextBlock{fl, "import \"DPI-C\" function longint " + m_libName + "_protectlib_combo_update " "(\n", - false, true); + false, true}; m_comboPortsp->addText(fl, "chandle handle__V\n"); txtp->addNodep(m_comboPortsp); txtp->addText(fl, ");\n\n"); seqComment(txtp, fl); if (m_hasClk) { - m_seqPortsp = new AstTextBlock(fl, + m_seqPortsp = new AstTextBlock{fl, "import \"DPI-C\" function longint " + m_libName + "_protectlib_seq_update" "(\n", - false, true); + false, true}; m_seqPortsp->addText(fl, "chandle handle__V\n"); txtp->addNodep(m_seqPortsp); txtp->addText(fl, ");\n\n"); } comboIgnoreComment(txtp, fl); - m_comboIgnorePortsp = new AstTextBlock(fl, + m_comboIgnorePortsp = new AstTextBlock{fl, "import \"DPI-C\" function void " + m_libName + "_protectlib_combo_ignore" "(\n", - false, true); + false, true}; m_comboIgnorePortsp->addText(fl, "chandle handle__V\n"); txtp->addNodep(m_comboIgnorePortsp); txtp->addText(fl, ");\n\n"); @@ -225,17 +225,17 @@ private: if (m_hasClk) txtp->addText(fl, "time last_seq_seqnum__V;\n"); txtp->addText(fl, "\n"); - m_comboDeclsp = new AstTextBlock(fl); + m_comboDeclsp = new AstTextBlock{fl}; txtp->addNodep(m_comboDeclsp); - m_seqDeclsp = new AstTextBlock(fl); + m_seqDeclsp = new AstTextBlock{fl}; txtp->addNodep(m_seqDeclsp); - m_tmpDeclsp = new AstTextBlock(fl); + m_tmpDeclsp = new AstTextBlock{fl}; txtp->addNodep(m_tmpDeclsp); // CPP hash value addComment(txtp, fl, "Hash value to make sure this file and the corresponding"); addComment(txtp, fl, "library agree"); - m_hashValuep = new AstTextBlock(fl, "localparam int protectlib_hash__V = 32'd"); + m_hashValuep = new AstTextBlock{fl, "localparam int protectlib_hash__V = 32'd"}; txtp->addNodep(m_hashValuep); txtp->addText(fl, "\n"); @@ -249,11 +249,11 @@ private: // Combinatorial process addComment(txtp, fl, "Combinatorialy evaluate changes to inputs"); - m_comboParamsp = new AstTextBlock(fl, + m_comboParamsp = new AstTextBlock{fl, "always @(*) begin\n" "last_combo_seqnum__V = " + m_libName + "_protectlib_combo_update(\n", - false, true); + false, true}; m_comboParamsp->addText(fl, "handle__V\n"); txtp->addNodep(m_comboParamsp); txtp->addText(fl, ");\n"); @@ -262,21 +262,21 @@ private: // Sequential process if (m_hasClk) { addComment(txtp, fl, "Evaluate clock edges"); - m_clkSensp = new AstTextBlock(fl, "always @(", false, true); + m_clkSensp = new AstTextBlock{fl, "always @(", false, true}; txtp->addNodep(m_clkSensp); txtp->addText(fl, ") begin\n"); m_comboIgnoreParamsp - = new AstTextBlock(fl, m_libName + "_protectlib_combo_ignore(\n", false, true); + = new AstTextBlock{fl, m_libName + "_protectlib_combo_ignore(\n", false, true}; m_comboIgnoreParamsp->addText(fl, "handle__V\n"); txtp->addNodep(m_comboIgnoreParamsp); txtp->addText(fl, ");\n"); - m_seqParamsp = new AstTextBlock( + m_seqParamsp = new AstTextBlock{ fl, "last_seq_seqnum__V <= " + m_libName + "_protectlib_seq_update(\n", false, - true); + true}; m_seqParamsp->addText(fl, "handle__V\n"); txtp->addNodep(m_seqParamsp); txtp->addText(fl, ");\n"); - m_nbAssignsp = new AstTextBlock(fl); + m_nbAssignsp = new AstTextBlock{fl}; txtp->addNodep(m_nbAssignsp); txtp->addText(fl, "end\n\n"); } @@ -285,14 +285,14 @@ private: addComment(txtp, fl, "Select between combinatorial and sequential results"); txtp->addText(fl, "always @(*) begin\n"); if (m_hasClk) { - m_seqAssignsp = new AstTextBlock(fl, "if (last_seq_seqnum__V > " - "last_combo_seqnum__V) begin\n"); + m_seqAssignsp = new AstTextBlock{fl, "if (last_seq_seqnum__V > " + "last_combo_seqnum__V) begin\n"}; txtp->addNodep(m_seqAssignsp); - m_comboAssignsp = new AstTextBlock(fl, "end\nelse begin\n"); + m_comboAssignsp = new AstTextBlock{fl, "end\nelse begin\n"}; txtp->addNodep(m_comboAssignsp); txtp->addText(fl, "end\n"); } else { - m_comboAssignsp = new AstTextBlock(fl, ""); + m_comboAssignsp = new AstTextBlock{fl, ""}; txtp->addNodep(m_comboAssignsp); } txtp->addText(fl, "end\n\n"); @@ -313,7 +313,7 @@ private: void createCppFile(FileLine* fl) { // Comments - AstTextBlock* const txtp = new AstTextBlock(fl); + AstTextBlock* const txtp = new AstTextBlock{fl}; addComment(txtp, fl, "Wrapper functions for DPI protected library\n"); // Includes @@ -339,7 +339,7 @@ private: txtp->addText(fl, "void " + m_libName + "_protectlib_check_hash" "(int protectlib_hash__V) {\n"); - m_cHashValuep = new AstTextBlock(fl, "const int expected_hash__V = "); + m_cHashValuep = new AstTextBlock{fl, "const int expected_hash__V = "}; txtp->addNodep(m_cHashValuep); txtp->addText(fl, /**/ "if (protectlib_hash__V != expected_hash__V) {\n"); txtp->addText(fl, /****/ "fprintf(stderr, \"%%Error: cannot use " + m_libName @@ -360,38 +360,38 @@ private: // Updates comboComment(txtp, fl); - m_cComboParamsp = new AstTextBlock( - fl, "long long " + m_libName + "_protectlib_combo_update(\n", false, true); + m_cComboParamsp = new AstTextBlock{ + fl, "long long " + m_libName + "_protectlib_combo_update(\n", false, true}; m_cComboParamsp->addText(fl, "void* vhandlep__V\n"); txtp->addNodep(m_cComboParamsp); txtp->addText(fl, ")\n"); - m_cComboInsp = new AstTextBlock(fl, "{\n"); + m_cComboInsp = new AstTextBlock{fl, "{\n"}; castPtr(fl, m_cComboInsp); txtp->addNodep(m_cComboInsp); - m_cComboOutsp = new AstTextBlock(fl, "handlep__V->eval();\n"); + m_cComboOutsp = new AstTextBlock{fl, "handlep__V->eval();\n"}; txtp->addNodep(m_cComboOutsp); txtp->addText(fl, "return handlep__V->m_seqnum++;\n"); txtp->addText(fl, "}\n\n"); if (m_hasClk) { seqComment(txtp, fl); - m_cSeqParamsp = new AstTextBlock( - fl, "long long " + m_libName + "_protectlib_seq_update(\n", false, true); + m_cSeqParamsp = new AstTextBlock{ + fl, "long long " + m_libName + "_protectlib_seq_update(\n", false, true}; m_cSeqParamsp->addText(fl, "void* vhandlep__V\n"); txtp->addNodep(m_cSeqParamsp); txtp->addText(fl, ")\n"); - m_cSeqClksp = new AstTextBlock(fl, "{\n"); + m_cSeqClksp = new AstTextBlock{fl, "{\n"}; castPtr(fl, m_cSeqClksp); txtp->addNodep(m_cSeqClksp); - m_cSeqOutsp = new AstTextBlock(fl, "handlep__V->eval();\n"); + m_cSeqOutsp = new AstTextBlock{fl, "handlep__V->eval();\n"}; txtp->addNodep(m_cSeqOutsp); txtp->addText(fl, "return handlep__V->m_seqnum++;\n"); txtp->addText(fl, "}\n\n"); } comboIgnoreComment(txtp, fl); - m_cIgnoreParamsp = new AstTextBlock( - fl, "void " + m_libName + "_protectlib_combo_ignore(\n", false, true); + m_cIgnoreParamsp = new AstTextBlock{ + fl, "void " + m_libName + "_protectlib_combo_ignore(\n", false, true}; m_cIgnoreParamsp->addText(fl, "void* vhandlep__V\n"); txtp->addNodep(m_cIgnoreParamsp); txtp->addText(fl, ")\n"); @@ -472,7 +472,7 @@ private: static void addLocalVariable(AstTextBlock* textp, AstVar* varp, const char* suffix) { AstVar* const newVarp - = new AstVar(varp->fileline(), VVarType::VAR, varp->name() + suffix, varp->dtypep()); + = new AstVar{varp->fileline(), VVarType::VAR, varp->name() + suffix, varp->dtypep()}; textp->addNodep(newVarp); } @@ -532,5 +532,5 @@ public: void V3ProtectLib::protect() { UINFO(2, __FUNCTION__ << ": " << endl); - ProtectVisitor(v3Global.rootp()); + ProtectVisitor{v3Global.rootp()}; } From 9d9d647c1f6d63e0d4c6e16a83dead52cac48db9 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Mon, 29 Aug 2022 22:28:02 -0400 Subject: [PATCH 6/9] Fix indentation of --protect import function SV code. --- src/V3File.cpp | 8 +++++++- src/V3File.h | 1 + src/V3ProtectLib.cpp | 4 ++-- 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/src/V3File.cpp b/src/V3File.cpp index 98e4d5628..54aef8915 100644 --- a/src/V3File.cpp +++ b/src/V3File.cpp @@ -654,6 +654,10 @@ bool V3OutFormatter::tokenEnd(const char* cp) { || tokenMatch(cp, "endtask")); } +bool V3OutFormatter::tokenNotStart(const char* cp) { + return (tokenMatch(cp, "export") || tokenMatch(cp, "import")); +} + int V3OutFormatter::endLevels(const char* strg) { int levels = m_indentLevel; { @@ -702,12 +706,14 @@ void V3OutFormatter::puts(const char* strg) { putsNoTracking(indentSpaces(endLevels(strg))); m_prependIndent = false; } + bool notstart = false; bool wordstart = true; bool equalsForBracket = false; // Looking for "= {" for (const char* cp = strg; *cp; ++cp) { putcNoTracking(*cp); if (isalpha(*cp)) { - if (wordstart && m_lang == LA_VERILOG && tokenStart(cp)) indentInc(); + if (wordstart && m_lang == LA_VERILOG && tokenNotStart(cp)) notstart = true; + if (wordstart && m_lang == LA_VERILOG && !notstart && tokenStart(cp)) indentInc(); if (wordstart && m_lang == LA_VERILOG && tokenEnd(cp)) indentDec(); } switch (*cp) { diff --git a/src/V3File.h b/src/V3File.h index 28c49e326..309f136c9 100644 --- a/src/V3File.h +++ b/src/V3File.h @@ -173,6 +173,7 @@ public: // Add escaped characters to strings static string quoteNameControls(const string& namein, Language lang = LA_C); static bool tokenMatch(const char* cp, const char* cmp); + static bool tokenNotStart(const char* cp); // Import/export meaning no endfunction static bool tokenStart(const char* cp); static bool tokenEnd(const char* cp); diff --git a/src/V3ProtectLib.cpp b/src/V3ProtectLib.cpp index 0bb5db9a5..1c7631e8a 100644 --- a/src/V3ProtectLib.cpp +++ b/src/V3ProtectLib.cpp @@ -250,7 +250,7 @@ private: // Combinatorial process addComment(txtp, fl, "Combinatorialy evaluate changes to inputs"); m_comboParamsp = new AstTextBlock{fl, - "always @(*) begin\n" + "always @* begin\n" "last_combo_seqnum__V = " + m_libName + "_protectlib_combo_update(\n", false, true}; @@ -283,7 +283,7 @@ private: // Select between combinatorial and sequential results addComment(txtp, fl, "Select between combinatorial and sequential results"); - txtp->addText(fl, "always @(*) begin\n"); + txtp->addText(fl, "always @* begin\n"); if (m_hasClk) { m_seqAssignsp = new AstTextBlock{fl, "if (last_seq_seqnum__V > " "last_combo_seqnum__V) begin\n"}; From c335aad25f395aeb3aad15760bf67e9b7e28ed87 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Mon, 29 Aug 2022 22:49:19 -0400 Subject: [PATCH 7/9] Fix --hierarchical with order-based pin connections (#3583). --- Changes | 1 + src/V3VariableOrder.cpp | 19 ++++++++++--------- test_regress/t/t_hier_bynum.pl | 19 +++++++++++++++++++ test_regress/t/t_hier_bynum.v | 29 +++++++++++++++++++++++++++++ 4 files changed, 59 insertions(+), 9 deletions(-) create mode 100755 test_regress/t/t_hier_bynum.pl create mode 100644 test_regress/t/t_hier_bynum.v diff --git a/Changes b/Changes index 3dd9088a4..bcbbbb381 100644 --- a/Changes +++ b/Changes @@ -21,6 +21,7 @@ Verilator 4.225 devel * Fix incorrect tristate logic (#3399) [shareefj, Vighnesh Iyer] * Fix segfault exporting non-existant package (#3535). * Fix case statement comparing string literal (#3544). [Gustav Svensk] +* Fix --hierarchical with order-based pin connections (#3583). [Kelin9298] * Improve Verilation speed with --threads on large designs. [Geza Lore] * Rename trace rolloverSize() (#3570). diff --git a/src/V3VariableOrder.cpp b/src/V3VariableOrder.cpp index 6dda8290b..d62cfb50f 100644 --- a/src/V3VariableOrder.cpp +++ b/src/V3VariableOrder.cpp @@ -156,15 +156,16 @@ class VariableOrder final { auto& attributes = m_attributes(varp); // Stratum const int sigbytes = varp->dtypeSkipRefp()->widthAlignBytes(); - attributes.stratum = (varp->isUsedClock() && varp->widthMin() == 1) ? 0 - : VN_IS(varp->dtypeSkipRefp(), UnpackArrayDType) ? 8 - : (varp->basicp() && varp->basicp()->isOpaque()) ? 7 - : (varp->isScBv() || varp->isScBigUint()) ? 6 - : (sigbytes == 8) ? 5 - : (sigbytes == 4) ? 4 - : (sigbytes == 2) ? 2 - : (sigbytes == 1) ? 1 - : 9; + attributes.stratum = (v3Global.opt.hierChild() && varp->isPrimaryIO()) ? 0 + : (varp->isUsedClock() && varp->widthMin() == 1) ? 1 + : VN_IS(varp->dtypeSkipRefp(), UnpackArrayDType) ? 9 + : (varp->basicp() && varp->basicp()->isOpaque()) ? 8 + : (varp->isScBv() || varp->isScBigUint()) ? 7 + : (sigbytes == 8) ? 6 + : (sigbytes == 4) ? 5 + : (sigbytes == 2) ? 3 + : (sigbytes == 1) ? 2 + : 10; // Anonymous structure ok attributes.anonOk = EmitCBaseVisitor::isAnonOk(varp); } diff --git a/test_regress/t/t_hier_bynum.pl b/test_regress/t/t_hier_bynum.pl new file mode 100755 index 000000000..2c0fb4904 --- /dev/null +++ b/test_regress/t/t_hier_bynum.pl @@ -0,0 +1,19 @@ +#!/usr/bin/perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2003 by Wilson Snyder. This program is free software; you can +# redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. + +scenarios(vlt_all => 1); + +compile( + v_flags2 => ['t/t_hier_block.cpp'], + verilator_flags2 => ['--hierarchical'], + verilator_make_gmake => 0, + ); + +ok(1); +1; diff --git a/test_regress/t/t_hier_bynum.v b/test_regress/t/t_hier_bynum.v new file mode 100644 index 000000000..4f930143d --- /dev/null +++ b/test_regress/t/t_hier_bynum.v @@ -0,0 +1,29 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed into the Public Domain, for any use, +// without warranty, 2022 by Wilson Snyder. + +module flop ( + output reg q, + input wire d, + input wire clk + ); + + // verilator hier_block + + always_ff @(posedge clk) begin + q <= d; + end + +endmodule + +module t ( + output wire q, + input wire d, + input wire clk + ); + + // This intentionally uses pin number ordering + flop u_flop(q, d, clk); + +endmodule From 8658a0d7dc61260cc4d6cbb69e91a7e5c50e7b24 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Mon, 29 Aug 2022 23:05:52 -0400 Subject: [PATCH 8/9] Internals: Constructor format update. No functional change. --- src/V3Number_test.cpp | 10 +++++----- src/V3ParseSym.h | 4 ++-- src/V3Trace.cpp | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/V3Number_test.cpp b/src/V3Number_test.cpp index 9aa4ba26c..2e7d090dd 100644 --- a/src/V3Number_test.cpp +++ b/src/V3Number_test.cpp @@ -34,12 +34,12 @@ void test(const string& lhss, const string& op, const string& rhss, const string char* r1 = strdup(rhss.c_str()); char* e1 = strdup(exps.c_str()); - const FileLine fl = new FileLine(FileLine::builtInFinename()); + const FileLine fl = new FileLine{FileLine::builtInFinename()}; - V3Number lhnum(fl, l1); - V3Number rhnum(fl, r1); - V3Number expnum(fl, e1); - V3Number gotnum(fl, expnum.width()); + V3Number lhnum{fl, l1}; + V3Number rhnum{fl, r1}; + V3Number expnum{fl, e1}; + V3Number gotnum{fl, expnum.width()}; if (op == "redOr") { gotnum.opRedOr(lhnum); diff --git a/src/V3ParseSym.h b/src/V3ParseSym.h index 3a60bfbea..87edaef5a 100644 --- a/src/V3ParseSym.h +++ b/src/V3ParseSym.h @@ -67,7 +67,7 @@ public: VSymEnt* findNewTable(AstNode* nodep) { if (!nodep->user4p()) { - VSymEnt* const symsp = new VSymEnt(&m_syms, nodep); + VSymEnt* const symsp = new VSymEnt{&m_syms, nodep}; nodep->user4p(symsp); } return getTable(nodep); @@ -87,7 +87,7 @@ public: void reinsert(AstNode* nodep, VSymEnt* parentp, string name) { if (!parentp) parentp = symCurrentp(); if (name == "") { // New name with space in name so can't collide with users - name = string(" anon") + nodep->type().ascii() + cvtToStr(++s_anonNum); + name = std::string{" anon"} + nodep->type().ascii() + cvtToStr(++s_anonNum); } parentp->reinsert(name, findNewTable(nodep)); } diff --git a/src/V3Trace.cpp b/src/V3Trace.cpp index b6fbb95ce..9a1fe1e3c 100644 --- a/src/V3Trace.cpp +++ b/src/V3Trace.cpp @@ -83,7 +83,7 @@ public: if (activityAlways()) { return "*ALWAYS*"; } else { - return (string(slow() ? "*SLOW* " : "")) + insertp()->name(); + return std::string{slow() ? "*SLOW* " : ""} + insertp()->name(); } } virtual string dotColor() const override { return slow() ? "yellowGreen" : "green"; } From 6a5f77b278baad22bf6d3e9c48813577ec542f09 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Mon, 29 Aug 2022 23:50:32 -0400 Subject: [PATCH 9/9] Internals: Cleanup some string/model constructors. No functional change. --- include/verilated_fst_sc.cpp | 2 +- include/verilated_vcd_sc.cpp | 2 +- src/V3Ast.h | 2 +- src/V3AstNodes.cpp | 2 +- src/V3Common.cpp | 2 +- src/V3EmitCFunc.cpp | 8 ++++---- src/V3EmitCImp.cpp | 4 ++-- src/V3EmitV.cpp | 4 ++-- src/V3FileLine.cpp | 2 +- src/V3LinkDot.cpp | 3 ++- src/V3OptionParser.cpp | 2 +- src/V3Options.cpp | 4 ++-- src/V3Param.cpp | 2 +- src/V3PreLex.l | 2 +- src/V3PreProc.cpp | 26 ++++++++++++++------------ src/V3ProtectLib.cpp | 11 ++++++----- src/V3String.h | 2 +- src/V3TraceDecl.cpp | 4 ++-- test_regress/t/t_dpi_var.cpp | 6 +++--- test_regress/t/t_embed1_c.cpp | 2 +- test_regress/t/t_mem_multi_io2.cpp | 2 +- test_regress/t/t_mem_multi_io3.cpp | 2 +- test_regress/t/t_multitop_sig.cpp | 2 +- test_regress/t/t_sc_names.cpp | 2 +- test_regress/t/t_timescale_parse.cpp | 2 +- test_regress/t/t_trace_public_sig.cpp | 2 +- test_regress/t/t_trace_two_sc.cpp | 4 ++-- test_regress/t/t_tri_gate.cpp | 2 +- test_regress/t/t_tri_inout.cpp | 2 +- test_regress/t/t_tri_inz.cpp | 2 +- test_regress/t/t_tri_pullup.cpp | 2 +- test_regress/t/t_tri_select.cpp | 2 +- test_regress/t/t_var_overwidth_bad.cpp | 2 +- test_regress/t/t_var_pinsizes.cpp | 4 ++-- test_regress/t/t_vpi_memory.cpp | 2 +- test_regress/t/t_vpi_param.cpp | 4 ++-- test_regress/t/t_vpi_sc.cpp | 2 +- test_regress/t/t_vpi_var.cpp | 2 +- test_regress/t/t_vpi_zero_time_cb.cpp | 2 +- test_regress/t/t_wrapper_context.cpp | 2 +- test_regress/t/t_wrapper_legacy.cpp | 2 +- test_regress/t/t_x_assign.cpp | 2 +- 42 files changed, 73 insertions(+), 69 deletions(-) diff --git a/include/verilated_fst_sc.cpp b/include/verilated_fst_sc.cpp index 2acb38781..f6bfeb41a 100644 --- a/include/verilated_fst_sc.cpp +++ b/include/verilated_fst_sc.cpp @@ -31,7 +31,7 @@ void VerilatedFstSc::open(const char* filename) { if (!sc_core::sc_get_curr_simcontext()->elaboration_done()) { vl_fatal(__FILE__, __LINE__, "VerilatedFstSc", - ("%Error: VerilatedFstSc::open(\"" + std::string(filename) + ("%Error: VerilatedFstSc::open(\"" + std::string{filename} + "\") is called before sc_core::sc_start(). " "Run sc_core::sc_start(sc_core::SC_ZERO_TIME) before opening a wave file.") .c_str()); diff --git a/include/verilated_vcd_sc.cpp b/include/verilated_vcd_sc.cpp index 20f9a426a..a7286d050 100644 --- a/include/verilated_vcd_sc.cpp +++ b/include/verilated_vcd_sc.cpp @@ -31,7 +31,7 @@ void VerilatedVcdSc::open(const char* filename) { if (!sc_core::sc_get_curr_simcontext()->elaboration_done()) { vl_fatal(__FILE__, __LINE__, "VerilatedVcdSc", - ("%Error: VerilatedVcdSc::open(\"" + std::string(filename) + ("%Error: VerilatedVcdSc::open(\"" + std::string{filename} + "\") is called before sc_core::sc_start(). " "Run sc_core::sc_start(sc_core::SC_ZERO_TIME) before opening a wave file.") .c_str()); diff --git a/src/V3Ast.h b/src/V3Ast.h index c3243b30d..b05c43318 100644 --- a/src/V3Ast.h +++ b/src/V3Ast.h @@ -1565,7 +1565,7 @@ public: static string dedotName(const string& namein); // Name with dots removed static string prettyName(const string& namein); // Name for printing out to the user static string prettyNameQ(const string& namein) { // Quoted pretty name (for errors) - return string("'") + prettyName(namein) + "'"; + return std::string{"'"} + prettyName(namein) + "'"; } static string encodeName(const string& namein); // Encode user name into internal C representation diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp index cf226075d..f8a409247 100644 --- a/src/V3AstNodes.cpp +++ b/src/V3AstNodes.cpp @@ -481,7 +481,7 @@ string AstVar::cPubArgType(bool named, bool forReturn) const { } } else { // Newer internal-compatible types - arg += dtypep()->cType((named ? name() : string{}), true, isRef); + arg += dtypep()->cType((named ? name() : std::string{}), true, isRef); } return arg; } diff --git a/src/V3Common.cpp b/src/V3Common.cpp index 6f983809c..76521a3fd 100644 --- a/src/V3Common.cpp +++ b/src/V3Common.cpp @@ -51,7 +51,7 @@ static void makeToString(AstClass* nodep) { funcp->isStatic(false); funcp->protect(false); AstNode* const exprp - = new AstCMath{nodep->fileline(), R"(std::string("'{") + to_string_middle() + "}")", 0}; + = new AstCMath{nodep->fileline(), R"(std::string{"'{"} + to_string_middle() + "}")", 0}; exprp->dtypeSetString(); funcp->addStmtsp(new AstCReturn{nodep->fileline(), exprp}); nodep->addStmtp(funcp); diff --git a/src/V3EmitCFunc.cpp b/src/V3EmitCFunc.cpp index 8f97b1139..3bda90bb6 100644 --- a/src/V3EmitCFunc.cpp +++ b/src/V3EmitCFunc.cpp @@ -455,9 +455,9 @@ void EmitCFunc::emitDereference(const string& pointer) { void EmitCFunc::emitCvtPackStr(AstNode* nodep) { if (const AstConst* const constp = VN_CAST(nodep, Const)) { - putbs("std::string("); + putbs("std::string{"); putsQuoted(constp->num().toString()); - puts(")"); + puts("}"); } else { putbs("VL_CVT_PACK_STR_N"); emitIQW(nodep); @@ -486,9 +486,9 @@ void EmitCFunc::emitConstant(AstConst* nodep, AstVarRef* assigntop, const string if (nodep->num().isFourState()) { nodep->v3warn(E_UNSUPPORTED, "Unsupported: 4-state numbers in this context"); } else if (nodep->num().isString()) { - putbs("std::string("); + putbs("std::string{"); putsQuoted(nodep->num().toString()); - puts(")"); + puts("}"); } else if (nodep->isWide()) { int upWidth = nodep->num().widthMin(); int chunks = 0; diff --git a/src/V3EmitCImp.cpp b/src/V3EmitCImp.cpp index c6985dd30..9bea7b2c0 100644 --- a/src/V3EmitCImp.cpp +++ b/src/V3EmitCImp.cpp @@ -314,8 +314,8 @@ class EmitCImp final : EmitCFunc { puts(" \"lineno\",lineno,"); puts(" \"column\",column,\n"); // Need to move hier into scopes and back out if do this - // puts( "\"hier\",std::string(vlSymsp->name())+hierp,"); - puts("\"hier\",std::string(name())+hierp,"); + // puts( "\"hier\",std::string{vlSymsp->name()} + hierp,"); + puts("\"hier\",std::string{name()} + hierp,"); puts(" \"page\",pagep,"); puts(" \"comment\",commentp,"); puts(" (linescovp[0] ? \"linescov\" : \"\"), linescovp);\n"); diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp index 77c58d9af..1bd2c3a47 100644 --- a/src/V3EmitV.cpp +++ b/src/V3EmitV.cpp @@ -208,7 +208,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor { putqs(nodep, "end\n"); } virtual void visit(AstComment* nodep) override { - puts(string("// ") + nodep->name() + "\n"); + puts(std::string{"// "} + nodep->name() + "\n"); iterateChildrenConst(nodep); } virtual void visit(AstContinue*) override { @@ -706,7 +706,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor { virtual void visit(AstCell*) override {} // Handled outside the Visit class // Default virtual void visit(AstNode* nodep) override { - puts(string("\n???? // ") + nodep->prettyTypeName() + "\n"); + puts(std::string{"\n???? // "} + nodep->prettyTypeName() + "\n"); iterateChildrenConst(nodep); // Not v3fatalSrc so we keep processing if (!m_suppressUnknown) { diff --git a/src/V3FileLine.cpp b/src/V3FileLine.cpp index 2e5a5fbef..6b7b2e58b 100644 --- a/src/V3FileLine.cpp +++ b/src/V3FileLine.cpp @@ -166,7 +166,7 @@ string FileLine::xmlDetailedLocation() const { } string FileLine::lineDirectiveStrg(int enterExit) const { - return std::string("`line ") + cvtToStr(lastLineno()) + " \"" + filename() + "\" " + return std::string{"`line "} + cvtToStr(lastLineno()) + " \"" + filename() + "\" " + cvtToStr(enterExit) + "\n"; } diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp index f5dc1b59e..f6961692e 100644 --- a/src/V3LinkDot.cpp +++ b/src/V3LinkDot.cpp @@ -1006,7 +1006,8 @@ class LinkDotFindVisitor final : public VNVisitor { m_classOrPackagep = VN_AS(m_curSymp->nodep(), Class); } // Create symbol table for the task's vars - const string name = string{nodep->isExternProto() ? "extern " : ""} + nodep->name(); + const string name + = std::string{nodep->isExternProto() ? "extern " : ""} + nodep->name(); m_curSymp = m_statep->insertBlock(m_curSymp, name, nodep, m_classOrPackagep); m_curSymp->fallbackp(upSymp); // Convert the func's range to the output variable diff --git a/src/V3OptionParser.cpp b/src/V3OptionParser.cpp index f9d5c721d..308a26e10 100644 --- a/src/V3OptionParser.cpp +++ b/src/V3OptionParser.cpp @@ -140,7 +140,7 @@ V3OptionParser::ActionIfs* V3OptionParser::find(const char* optp) { if (act.second->isOnOffAllowed()) { // Find starts with "-no" if (const char* const nop = VString::startsWith(optp, "-no") ? (optp + strlen("-no")) : nullptr) { - if (act.first == nop || act.first == (string{"-"} + nop)) { + if (act.first == nop || act.first == (std::string{"-"} + nop)) { return act.second.get(); } } diff --git a/src/V3Options.cpp b/src/V3Options.cpp index f780cf106..d88f6df3c 100644 --- a/src/V3Options.cpp +++ b/src/V3Options.cpp @@ -1436,7 +1436,7 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc, char }); DECL_OPTION("-Wno-", CbPartialMatch, [fl, &parser](const char* optp) { if (!FileLine::globalWarnOff(optp, true)) { - const string fullopt = string{"-Wno-"} + optp; + const string fullopt = std::string{"-Wno-"} + optp; fl->v3fatal("Unknown warning specified: " << fullopt << parser.getSuggestion(fullopt.c_str())); } @@ -1456,7 +1456,7 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc, char const V3ErrorCode code{optp}; if (code == V3ErrorCode::EC_ERROR) { if (!isFuture(optp)) { - const string fullopt = string{"-Wwarn-"} + optp; + const string fullopt = std::string{"-Wwarn-"} + optp; fl->v3fatal("Unknown warning specified: " << fullopt << parser.getSuggestion(fullopt.c_str())); } diff --git a/src/V3Param.cpp b/src/V3Param.cpp index 8c1595194..73e306f69 100644 --- a/src/V3Param.cpp +++ b/src/V3Param.cpp @@ -969,7 +969,7 @@ class ParamVisitor final : public VNVisitor { // A generic visitor for cells and class refs void visitCellOrClassRef(AstNode* nodep, bool isIface) { // Must do ifaces first, so push to list and do in proper order - string* const genHierNamep = new string{m_generateHierName}; + string* const genHierNamep = new std::string{m_generateHierName}; nodep->user5p(genHierNamep); // Visit parameters in the instantiation. iterateChildren(nodep); diff --git a/src/V3PreLex.l b/src/V3PreLex.l index c53a675eb..bfe69e7c7 100644 --- a/src/V3PreLex.l +++ b/src/V3PreLex.l @@ -618,7 +618,7 @@ void V3PreLex::scanNewFile(FileLine* filelinep) { void V3PreLex::scanBytes(const string& str) { // Note buffers also appended in ::scanBytesBack - // Not "m_buffers.push_front(string{strp,len})" as we need a `define + // Not "m_buffers.push_front(std::string{strp,len})" as we need a `define // to take effect immediately, in the middle of the current buffer // Also we don't use scan_bytes that would set yy_fill_buffer // which would force Flex to bypass our YY_INPUT routine. diff --git a/src/V3PreProc.cpp b/src/V3PreProc.cpp index 33fffc337..dba2e5a39 100644 --- a/src/V3PreProc.cpp +++ b/src/V3PreProc.cpp @@ -328,7 +328,7 @@ FileLine* V3PreProcImp::defFileline(const string& name) { void V3PreProcImp::define(FileLine* fl, const string& name, const string& value, const string& params, bool cmdline) { UINFO(4, "DEFINE '" << name << "' as '" << value << "' params '" << params << "'" << endl); - if (!V3LanguageWords::isKeyword(string("`") + name).empty()) { + if (!V3LanguageWords::isKeyword(std::string{"`"} + name).empty()) { fl->v3error("Attempting to define built-in directive: '`" << name << "' (IEEE 1800-2017 22.5.1)"); } else { @@ -886,7 +886,7 @@ void V3PreProcImp::dumpDefines(std::ostream& os) { void V3PreProcImp::candidateDefines(VSpellCheck* spellerp) { for (DefinesMap::const_iterator it = m_defines.begin(); it != m_defines.end(); ++it) { - spellerp->pushCandidate(string("`") + it->first); + spellerp->pushCandidate(std::string{"`"} + it->first); } } @@ -1106,7 +1106,7 @@ int V3PreProcImp::getStateToken() { // IE, `ifdef `MACRO(x): Substitute and come back here when state pops. break; } else { - error(string("Expecting define name. Found: ") + tokenName(tok) + "\n"); + error(std::string{"Expecting define name. Found: "} + tokenName(tok) + "\n"); goto next_tok; } } @@ -1127,7 +1127,7 @@ int V3PreProcImp::getStateToken() { goto next_tok; } } else { - error(string("Expecting define formal arguments. Found: ") + tokenName(tok) + error(std::string{"Expecting define formal arguments. Found: "} + tokenName(tok) + "\n"); goto next_tok; } @@ -1164,7 +1164,8 @@ int V3PreProcImp::getStateToken() { define(fileline(), m_lastSym, value, formals, false); } } else { - const string msg = string("Bad define text, unexpected ") + tokenName(tok) + "\n"; + const string msg + = std::string{"Bad define text, unexpected "} + tokenName(tok) + "\n"; fatalSrc(msg); } statePop(); @@ -1182,7 +1183,7 @@ int V3PreProcImp::getStateToken() { fatalSrc("Shouldn't be in DEFPAREN w/o active defref"); } const VDefineRef* const refp = &(m_defRefs.top()); - error(string("Expecting ( to begin argument list for define reference `") + error(std::string{"Expecting ( to begin argument list for define reference `"} + refp->name() + "\n"); statePop(); goto next_tok; @@ -1259,7 +1260,8 @@ int V3PreProcImp::getStateToken() { statePush(ps_STRIFY); goto next_tok; } else { - error(string("Expecting ) or , to end argument list for define reference. Found: ") + error(std::string{ + "Expecting ) or , to end argument list for define reference. Found: "} + tokenName(tok)); statePop(); goto next_tok; @@ -1285,7 +1287,7 @@ int V3PreProcImp::getStateToken() { break; } else { statePop(); - error(string("Expecting include filename. Found: ") + tokenName(tok) + "\n"); + error(std::string{"Expecting include filename. Found: "} + tokenName(tok) + "\n"); goto next_tok; } } @@ -1298,7 +1300,7 @@ int V3PreProcImp::getStateToken() { statePop(); goto next_tok; } else { - error(string("Expecting `error string. Found: ") + tokenName(tok) + "\n"); + error(std::string{"Expecting `error string. Found: "} + tokenName(tok) + "\n"); statePop(); goto next_tok; } @@ -1343,7 +1345,7 @@ int V3PreProcImp::getStateToken() { // multiline "..." without \ escapes. // The spec is silent about this either way; simulators vary std::replace(out.begin(), out.end(), '\n', ' '); - unputString(string("\"") + out + "\""); + unputString(std::string{"\""} + out + "\""); statePop(); goto next_tok; } else if (tok == VP_EOF) { @@ -1427,7 +1429,7 @@ int V3PreProcImp::getStateToken() { } else { // We want final text of `name, but that would cause // recursion, so use a special character to get it through - unputDefrefString(string("`\032") + name); + unputDefrefString(std::string{"`\032"} + name); goto next_tok; } } else { @@ -1517,7 +1519,7 @@ int V3PreProcImp::getStateToken() { case VP_DEFFORM: // Handled by state=ps_DEFFORM; case VP_DEFVALUE: // Handled by state=ps_DEFVALUE; default: // LCOV_EXCL_LINE - fatalSrc(string("Internal error: Unexpected token ") + tokenName(tok) + "\n"); + fatalSrc(std::string{"Internal error: Unexpected token "} + tokenName(tok) + "\n"); break; // LCOV_EXCL_LINE } return tok; diff --git a/src/V3ProtectLib.cpp b/src/V3ProtectLib.cpp index 1c7631e8a..864513fc8 100644 --- a/src/V3ProtectLib.cpp +++ b/src/V3ProtectLib.cpp @@ -149,16 +149,17 @@ private: // Timescale if (v3Global.opt.hierChild() && v3Global.rootp()->timescaleSpecified()) { // Emit timescale for hierarhical verilation if input HDL specifies timespec - txtp->addText(fl, string("timeunit ") + modp->timeunit().ascii() + ";\n"); - txtp->addText(fl, string("timeprecision ") + +v3Global.rootp()->timeprecision().ascii() - + ";\n"); + txtp->addText(fl, std::string{"timeunit "} + modp->timeunit().ascii() + ";\n"); + txtp->addText(fl, std::string{"timeprecision "} + + +v3Global.rootp()->timeprecision().ascii() + ";\n"); } else { addComment(txtp, fl, "Precision of submodule" " (commented out to avoid requiring timescale on all modules)"); - addComment(txtp, fl, string("timeunit ") + v3Global.rootp()->timeunit().ascii() + ";"); addComment(txtp, fl, - string("timeprecision ") + v3Global.rootp()->timeprecision().ascii() + std::string{"timeunit "} + v3Global.rootp()->timeunit().ascii() + ";"); + addComment(txtp, fl, + std::string{"timeprecision "} + v3Global.rootp()->timeprecision().ascii() + ";\n"); } diff --git a/src/V3String.h b/src/V3String.h index 0da8bdfc7..1fbcecaf7 100644 --- a/src/V3String.h +++ b/src/V3String.h @@ -233,7 +233,7 @@ public: if (candidate.empty()) { return ""; } else { - return string("... Suggested alternative: '") + candidate + "'"; + return std::string{"... Suggested alternative: '"} + candidate + "'"; } } static void selfTest(); diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp index 3f9c1ae6a..6fc9a8726 100644 --- a/src/V3TraceDecl.cpp +++ b/src/V3TraceDecl.cpp @@ -379,7 +379,7 @@ private: addToSubFunc(new AstTracePushNamePrefix{flp, m_traName}); for (int i = nodep->lo(); i <= nodep->hi(); ++i) { VL_RESTORER(m_traValuep); - m_traName = string{"["} + cvtToStr(i) + string{"]"}; + m_traName = std::string{"["} + cvtToStr(i) + std::string{"]"}; m_traValuep = m_traValuep->cloneTree(false); m_traValuep = new AstArraySel{flp, m_traValuep, i - nodep->lo()}; m_traValuep->dtypep(subtypep); @@ -404,7 +404,7 @@ private: addToSubFunc(new AstTracePushNamePrefix{flp, m_traName}); for (int i = nodep->lo(); i <= nodep->hi(); ++i) { VL_RESTORER(m_traValuep); - m_traName = string{"["} + cvtToStr(i) + string{"]"}; + m_traName = std::string{"["} + cvtToStr(i) + std::string{"]"}; const int lsb = (i - nodep->lo()) * subtypep->width(); m_traValuep = m_traValuep->cloneTree(false); m_traValuep = new AstSel{flp, m_traValuep, lsb, subtypep->width()}; diff --git a/test_regress/t/t_dpi_var.cpp b/test_regress/t/t_dpi_var.cpp index 855e022b7..f35647d41 100644 --- a/test_regress/t/t_dpi_var.cpp +++ b/test_regress/t/t_dpi_var.cpp @@ -51,7 +51,7 @@ void mon_class_name(const char* namep) { #endif // Check the C's calling name of "" doesn't lead to extra dots in the name() if (namep && namep[0] == '.') - vl_fatal(__FILE__, __LINE__, "", (std::string("Unexp class name ") + namep).c_str()); + vl_fatal(__FILE__, __LINE__, "", (std::string{"Unexp class name "} + namep).c_str()); } extern "C" void mon_scope_name(const char* namep); @@ -61,9 +61,9 @@ void mon_scope_name(const char* namep) { VL_PRINTF("- mon_scope_name('%s', \"%s\");\n", modp, namep); #endif if (strcmp(namep, "t.sub")) - vl_fatal(__FILE__, __LINE__, "", (std::string("Unexp scope name ") + namep).c_str()); + vl_fatal(__FILE__, __LINE__, "", (std::string{"Unexp scope name "} + namep).c_str()); if (strcmp(modp, "t.sub")) - vl_fatal(__FILE__, __LINE__, "", (std::string("Unexp dpiscope name ") + modp).c_str()); + vl_fatal(__FILE__, __LINE__, "", (std::string{"Unexp dpiscope name "} + modp).c_str()); } extern "C" void mon_register_b(const char* namep, int isOut); diff --git a/test_regress/t/t_embed1_c.cpp b/test_regress/t/t_embed1_c.cpp index 0e6e075cb..ed536c524 100644 --- a/test_regress/t/t_embed1_c.cpp +++ b/test_regress/t/t_embed1_c.cpp @@ -56,7 +56,7 @@ Vt_embed1_child* __get_modelp() { // Create the model const char* scopenamep = svGetNameFromScope(scope); if (!scopenamep) vl_fatal(__FILE__, __LINE__, __FILE__, "svGetNameFromScope failed"); - __modelp = new Vt_embed1_child(scopenamep); + __modelp = new Vt_embed1_child{scopenamep}; if (svPutUserData(scope, &T_Embed_Child_Unique, __modelp)) { vl_fatal(__FILE__, __LINE__, __FILE__, "svPutUserData failed"); } diff --git a/test_regress/t/t_mem_multi_io2.cpp b/test_regress/t/t_mem_multi_io2.cpp index 507ac12b0..14e71c1a4 100644 --- a/test_regress/t/t_mem_multi_io2.cpp +++ b/test_regress/t/t_mem_multi_io2.cpp @@ -25,7 +25,7 @@ int main() #endif { Verilated::debug(0); - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; #ifdef SYSTEMC_VERSION sc_signal i3; diff --git a/test_regress/t/t_mem_multi_io3.cpp b/test_regress/t/t_mem_multi_io3.cpp index 9db98b288..8f2b519d9 100644 --- a/test_regress/t/t_mem_multi_io3.cpp +++ b/test_regress/t/t_mem_multi_io3.cpp @@ -18,7 +18,7 @@ int main() #endif { Verilated::debug(0); - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; tb->final(); VL_DO_DANGLING(delete tb, tb); diff --git a/test_regress/t/t_multitop_sig.cpp b/test_regress/t/t_multitop_sig.cpp index 91115cc41..0ce924bf8 100644 --- a/test_regress/t/t_multitop_sig.cpp +++ b/test_regress/t/t_multitop_sig.cpp @@ -20,7 +20,7 @@ double sc_time_stamp() { return 0; } int errors = 0; int main(int argc, char* argv[]) { - Vt_multitop_sig* topp = new Vt_multitop_sig(""); + Vt_multitop_sig* topp = new Vt_multitop_sig{""}; Verilated::debug(0); diff --git a/test_regress/t/t_sc_names.cpp b/test_regress/t/t_sc_names.cpp index ba71d8c14..6839252b0 100644 --- a/test_regress/t/t_sc_names.cpp +++ b/test_regress/t/t_sc_names.cpp @@ -9,7 +9,7 @@ VM_PREFIX* tb = nullptr; int sc_main(int argc, char* argv[]) { - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; std::vector ch = tb->get_child_objects(); bool found = false; diff --git a/test_regress/t/t_timescale_parse.cpp b/test_regress/t/t_timescale_parse.cpp index c1464fe97..128a1b2e8 100644 --- a/test_regress/t/t_timescale_parse.cpp +++ b/test_regress/t/t_timescale_parse.cpp @@ -12,7 +12,7 @@ double sc_time_stamp() { } int main() { - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; tb->eval(); tb->eval(); diff --git a/test_regress/t/t_trace_public_sig.cpp b/test_regress/t/t_trace_public_sig.cpp index 8cf387097..04d5be921 100644 --- a/test_regress/t/t_trace_public_sig.cpp +++ b/test_regress/t/t_trace_public_sig.cpp @@ -26,7 +26,7 @@ double sc_time_stamp() { return (double)main_time; } const unsigned long long dt_2 = 3; int main(int argc, char** argv, char** env) { - VM_PREFIX* top = new VM_PREFIX("top"); + VM_PREFIX* top = new VM_PREFIX{"top"}; Verilated::debug(0); Verilated::traceEverOn(true); diff --git a/test_regress/t/t_trace_two_sc.cpp b/test_regress/t/t_trace_two_sc.cpp index 232b932a6..118a2d0a1 100644 --- a/test_regress/t/t_trace_two_sc.cpp +++ b/test_regress/t/t_trace_two_sc.cpp @@ -33,8 +33,8 @@ int sc_main(int argc, char** argv) { Verilated::traceEverOn(true); Verilated::debug(0); srand48(5); - ap = new VM_PREFIX("topa"); - bp = new Vt_trace_two_b("topb"); + ap = new VM_PREFIX{"topa"}; + bp = new Vt_trace_two_b{"topb"}; ap->clk(clk); bp->clk(clk); diff --git a/test_regress/t/t_tri_gate.cpp b/test_regress/t/t_tri_gate.cpp index 66159175b..3981e94b7 100644 --- a/test_regress/t/t_tri_gate.cpp +++ b/test_regress/t/t_tri_gate.cpp @@ -36,7 +36,7 @@ int main() { bool pass = true; Verilated::debug(0); - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; // loop through every possibility and check the result for (tb->SEL = 0; tb->SEL < 2; tb->SEL++) { diff --git a/test_regress/t/t_tri_inout.cpp b/test_regress/t/t_tri_inout.cpp index 874c5f15b..8ce60aa11 100644 --- a/test_regress/t/t_tri_inout.cpp +++ b/test_regress/t/t_tri_inout.cpp @@ -36,7 +36,7 @@ int main() { bool pass = true; Verilated::debug(0); - tb = new Vt_tri_inout("tb"); + tb = new Vt_tri_inout{"tb"}; // loop through every possibility and check the result for (tb->SEL = 0; tb->SEL < 2; tb->SEL++) { diff --git a/test_regress/t/t_tri_inz.cpp b/test_regress/t/t_tri_inz.cpp index fb0934859..eccd5eaac 100644 --- a/test_regress/t/t_tri_inz.cpp +++ b/test_regress/t/t_tri_inz.cpp @@ -34,7 +34,7 @@ void check(int d, int en, int exp0, int exp1, int expx, int expz) { int main() { Verilated::debug(0); - tb = new Vt_tri_inz("tb"); + tb = new Vt_tri_inz{"tb"}; check(0, 1, 1, 0, 0, 0); check(1, 1, 0, 1, 0, 0); check(0, 0, 0, 0, 0, 1); diff --git a/test_regress/t/t_tri_pullup.cpp b/test_regress/t/t_tri_pullup.cpp index 12cbf9a1c..29aa72a9e 100644 --- a/test_regress/t/t_tri_pullup.cpp +++ b/test_regress/t/t_tri_pullup.cpp @@ -47,7 +47,7 @@ int main() { bool pass = true; Verilated::debug(0); - tb = new Vt_tri_pullup("tb"); + tb = new Vt_tri_pullup{"tb"}; // loop through every possibility and check the result for (tb->OE = 0; tb->OE < 2; tb->OE++) { diff --git a/test_regress/t/t_tri_select.cpp b/test_regress/t/t_tri_select.cpp index 0db6f19ef..a4c6ee54a 100644 --- a/test_regress/t/t_tri_select.cpp +++ b/test_regress/t/t_tri_select.cpp @@ -45,7 +45,7 @@ int main() { bool pass = true; Verilated::debug(0); - tb = new Vt_tri_select("tb"); + tb = new Vt_tri_select{"tb"}; // loop through every possibility and check the result for (tb->OE1 = 0; tb->OE1 < 2; tb->OE1++) { diff --git a/test_regress/t/t_var_overwidth_bad.cpp b/test_regress/t/t_var_overwidth_bad.cpp index d82237617..586314a73 100644 --- a/test_regress/t/t_var_overwidth_bad.cpp +++ b/test_regress/t/t_var_overwidth_bad.cpp @@ -22,7 +22,7 @@ double sc_time_stamp() { return main_time; } int main(int argc, char** argv, char** env) { Verilated::debug(0); - VM_PREFIX* topp = new VM_PREFIX(""); // Note null name - we're flattening it out + VM_PREFIX* topp = new VM_PREFIX{""}; // Note null name - we're flattening it out main_time = 0; diff --git a/test_regress/t/t_var_pinsizes.cpp b/test_regress/t/t_var_pinsizes.cpp index 5dc53e9e2..b898aa792 100644 --- a/test_regress/t/t_var_pinsizes.cpp +++ b/test_regress/t/t_var_pinsizes.cpp @@ -9,7 +9,7 @@ VM_PREFIX* tb = nullptr; int main() { Verilated::debug(0); - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; VL_PRINTF("*-* All Finished *-*\n"); tb->final(); @@ -18,7 +18,7 @@ int main() { } int sc_main(int argc, char* argv[]) { - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; VL_PRINTF("*-* All Finished *-*\n"); tb->final(); diff --git a/test_regress/t/t_vpi_memory.cpp b/test_regress/t/t_vpi_memory.cpp index 05a34a68d..64122cc24 100644 --- a/test_regress/t/t_vpi_memory.cpp +++ b/test_regress/t/t_vpi_memory.cpp @@ -138,7 +138,7 @@ void _mem_check(const char* name, int size, int left, int right, int words) { value.format = vpiBinStrVal; vpi_get_value(mem_h, &value); TEST_CHECK_Z(vpi_chk_error(&e)); - TEST_CHECK_EQ(std::string(value.value.str), binStr); + TEST_CHECK_EQ(std::string{value.value.str}, binStr); } // don't care for non verilator diff --git a/test_regress/t/t_vpi_param.cpp b/test_regress/t/t_vpi_param.cpp index 78f1deeed..51415a38b 100644 --- a/test_regress/t/t_vpi_param.cpp +++ b/test_regress/t/t_vpi_param.cpp @@ -101,7 +101,7 @@ int check_param_int(std::string name, PLI_INT32 format, int exp_value, bool verb p = vpi_get_str(vpiName, param_h); CHECK_RESULT_CSTR(p, name.c_str()); p = vpi_get_str(vpiFullName, param_h); - CHECK_RESULT_CSTR(p, std::string("t." + name).c_str()); + CHECK_RESULT_CSTR(p, std::string{"t." + name}.c_str()); p = vpi_get_str(vpiType, param_h); CHECK_RESULT_CSTR(p, "vpiParameter"); vpi_type = vpi_get(vpiLocalParam, param_h); @@ -155,7 +155,7 @@ int check_param_str(std::string name, PLI_INT32 format, std::string exp_value, b p = vpi_get_str(vpiName, param_h); CHECK_RESULT_CSTR(p, name.c_str()); p = vpi_get_str(vpiFullName, param_h); - CHECK_RESULT_CSTR(p, std::string("t." + name).c_str()); + CHECK_RESULT_CSTR(p, std::string{"t." + name}.c_str()); p = vpi_get_str(vpiType, param_h); CHECK_RESULT_CSTR(p, "vpiParameter"); vpi_type = vpi_get(vpiLocalParam, param_h); diff --git a/test_regress/t/t_vpi_sc.cpp b/test_regress/t/t_vpi_sc.cpp index 85c7b9078..759d6075b 100644 --- a/test_regress/t/t_vpi_sc.cpp +++ b/test_regress/t/t_vpi_sc.cpp @@ -8,7 +8,7 @@ VM_PREFIX* tb = nullptr; int sc_main(int argc, char* argv[]) { - tb = new VM_PREFIX("tb"); + tb = new VM_PREFIX{"tb"}; VL_PRINTF("*-* All Finished *-*\n"); tb->final(); diff --git a/test_regress/t/t_vpi_var.cpp b/test_regress/t/t_vpi_var.cpp index 5666bb3fd..b8186c281 100644 --- a/test_regress/t/t_vpi_var.cpp +++ b/test_regress/t/t_vpi_var.cpp @@ -536,7 +536,7 @@ int _mon_check_putget_str(p_cb_data cb_data) { CHECK_RESULT_CSTR(v.value.str, data[i].str.c_str()); } else { data[i].type = v.format; - data[i].str = std::string(v.value.str); + data[i].str = std::string{v.value.str}; } } diff --git a/test_regress/t/t_vpi_zero_time_cb.cpp b/test_regress/t/t_vpi_zero_time_cb.cpp index 56eea28ab..cd35de936 100644 --- a/test_regress/t/t_vpi_zero_time_cb.cpp +++ b/test_regress/t/t_vpi_zero_time_cb.cpp @@ -138,7 +138,7 @@ int main(int argc, char** argv, char** env) { void* lib = dlopen(filenamep, RTLD_LAZY); void* bootstrap = dlsym(lib, "vpi_compat_bootstrap"); if (!bootstrap) { - const std::string msg = std::string("%Error: Could not dlopen ") + filenamep; + const std::string msg = std::string{"%Error: Could not dlopen "} + filenamep; vl_fatal(__FILE__, __LINE__, "main", msg.c_str()); } ((void (*)(void))bootstrap)(); diff --git a/test_regress/t/t_wrapper_context.cpp b/test_regress/t/t_wrapper_context.cpp index b802e6787..c712cd603 100644 --- a/test_regress/t/t_wrapper_context.cpp +++ b/test_regress/t/t_wrapper_context.cpp @@ -84,7 +84,7 @@ void sim(VM_PREFIX* topp) { } std::string filename - = std::string(VL_STRINGIFY(TEST_OBJ_DIR) "/coverage_") + topp->name() + ".dat"; + = std::string{VL_STRINGIFY(TEST_OBJ_DIR) "/coverage_"} + topp->name() + ".dat"; contextp->coveragep()->write(filename.c_str()); } diff --git a/test_regress/t/t_wrapper_legacy.cpp b/test_regress/t/t_wrapper_legacy.cpp index 860e1a442..a2a5ac518 100644 --- a/test_regress/t/t_wrapper_legacy.cpp +++ b/test_regress/t/t_wrapper_legacy.cpp @@ -92,7 +92,7 @@ int main(int argc, char** argv, char** env) { TEST_CHECK_EQ(sizeof(vlsint32_t), 4); // Intentional use of old typedef TEST_CHECK_EQ(sizeof(vlsint64_t), 8); // Intentional use of old typedef - VM_PREFIX* topp = new VM_PREFIX(); + VM_PREFIX* topp = new VM_PREFIX{}; topp->eval(); topp->clk = 0; diff --git a/test_regress/t/t_x_assign.cpp b/test_regress/t/t_x_assign.cpp index 85aa51797..8d85b72bf 100644 --- a/test_regress/t/t_x_assign.cpp +++ b/test_regress/t/t_x_assign.cpp @@ -31,7 +31,7 @@ double sc_time_stamp() { return 0; } // clang-format on int main(int argc, const char** argv) { - VM_PREFIX* top = new VM_PREFIX(); + VM_PREFIX* top = new VM_PREFIX{}; #if defined(T_X_ASSIGN_UNIQUE_0) Verilated::randReset(0);