luke
/
verilator
mirror of https://github.com/verilator/verilator.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
verilator/src/V3ProtectLib.cpp

526 lines
22 KiB
C++
Raw Normal View History

Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// -*- mode: C++; c-file-style: "cc-mode" -*-
//*************************************************************************
// DESCRIPTION: Verilator: Build DPI protected C++ and SV
//
Update URLs to https://verilator.org
2019-11-08 04:33:59 +01:00
// Code available from: https://verilator.org
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
//
//*************************************************************************
//
Copyright year update.
2025-01-01 14:30:25 +01:00
// Copyright 2003-2025 by Wilson Snyder. This program is free software; you
Add SPDX license identifiers. No functional change.
2020-03-21 16:24:24 +01:00
// can redistribute it and/or modify it under the terms of either the GNU
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Lesser General Public License Version 3 or the Perl Artistic License
// Version 2.0.
Add SPDX license identifiers. No functional change.
2020-03-21 16:24:24 +01:00
// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
//
//*************************************************************************
Fix header order botched by clang-format in recent commit.
2023-10-18 12:37:46 +02:00
#include "V3PchAstNoMT.h" // VL_MT_DISABLED_CODE_UNIT
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
#include "V3ProtectLib.h"
Update clang-format config and apply - Regroup and sort #include directives (like we used to, but automatic) - Set AlwaysBreakTemplateDeclarations to true
2022-08-05 11:56:57 +02:00
Rename Verilator Config Files to Verilator Control Files. Avoids conflict with IEEE `config`. No functional change intended.
2025-06-28 02:38:01 +02:00
#include "V3Control.h"
Split V3Hashed to V3Hasher and V3DupFinder (#2967) V3Hasher is responsible for computing AstNode hashes, while V3DupFinder can be used to find duplicate trees based on hashes. Interface of V3DupFinder simplified somewhat. No functional change intended at this point, but hash computation might differ in minor details, this however should have no perceivable effect on output/runtime. Implements (#2964)
2021-05-21 02:41:46 +02:00
#include "V3Hasher.h"
Improve hierarchical DPI wrapper scheduling performance (#2583) (#5734)
2025-01-20 20:24:09 +01:00
#include "V3InstrCount.h"
Update clang-format config and apply - Regroup and sort #include directives (like we used to, but automatic) - Set AlwaysBreakTemplateDeclarations to true
2022-08-05 11:56:57 +02:00
#include "V3String.h"
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
#include "V3Task.h"
Streamline dump control options - Rename `--dump-treei` option to `--dumpi-tree`, which itself is now a special case of `--dumpi-<tag>` where tag can be a magic word, or a filename - Control dumping via static `dump*()` functions, analogous to `debug()` - Make dumping independent of the value of `debug()` (so dumping always works even without the debug flag) - Add separate `--dumpi-graph` for dumping V3Graphs, which is again a special case of `--dumpi-<tag>` - Alias `--dump-<tag>` to `--dumpi-<tag> 3` as before
2022-09-18 21:53:42 +02:00
VL_DEFINE_DEBUG_FUNCTIONS;
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
//######################################################################
// ProtectLib top-level visitor
Internals: Rename Ast on non-node classes (#3262). No functional change. This commit has the following replacements applied: s/\bAstUserInUseBase\b/VNUserInUseBase/g; s/\bAstAttrType\b/VAttrType/g; s/\bAstBasicDTypeKwd\b/VBasicDTypeKwd/g; s/\bAstDisplayType\b/VDisplayType/g; s/\bAstNDeleter\b/VNDeleter/g; s/\bAstNRelinker\b/VNRelinker/g; s/\bAstNVisitor\b/VNVisitor/g; s/\bAstPragmaType\b/VPragmaType/g; s/\bAstType\b/VNType/g; s/\bAstUser1InUse\b/VNUser1InUse/g; s/\bAstUser2InUse\b/VNUser2InUse/g; s/\bAstUser3InUse\b/VNUser3InUse/g; s/\bAstUser4InUse\b/VNUser4InUse/g; s/\bAstUser5InUse\b/VNUser5InUse/g; s/\bAstVarType\b/VVarType/g;
2022-01-02 19:56:40 +01:00
class ProtectVisitor final : public VNVisitor {
C++11: Use member declaration initalizations. No functional change intended.
2020-08-15 19:11:27 +02:00
AstVFile* m_vfilep = nullptr; // DPI-enabled Verilog wrapper
AstCFile* m_cfilep = nullptr; // C implementation of DPI functions
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Verilog text blocks
C++11: Use member declaration initalizations. No functional change intended.
2020-08-15 19:11:27 +02:00
AstTextBlock* m_modPortsp = nullptr; // Module port list
AstTextBlock* m_comboPortsp = nullptr; // Combo function port list
AstTextBlock* m_seqPortsp = nullptr; // Sequential function port list
AstTextBlock* m_comboIgnorePortsp = nullptr; // Combo ignore function port list
AstTextBlock* m_comboDeclsp = nullptr; // Combo signal declaration list
AstTextBlock* m_seqDeclsp = nullptr; // Sequential signal declaration list
AstTextBlock* m_tmpDeclsp = nullptr; // Temporary signal declaration list
AstTextBlock* m_hashValuep = nullptr; // CPP hash value
AstTextBlock* m_comboParamsp = nullptr; // Combo function parameter list
AstTextBlock* m_clkSensp = nullptr; // Clock sensitivity list
AstTextBlock* m_comboIgnoreParamsp = nullptr; // Combo ignore parameter list
AstTextBlock* m_seqParamsp = nullptr; // Sequential parameter list
AstTextBlock* m_nbAssignsp = nullptr; // Non-blocking assignment list
AstTextBlock* m_seqAssignsp = nullptr; // Sequential assignment list
AstTextBlock* m_comboAssignsp = nullptr; // Combo assignment list
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// C text blocks
C++11: Use member declaration initalizations. No functional change intended.
2020-08-15 19:11:27 +02:00
AstTextBlock* m_cHashValuep = nullptr; // CPP hash value
AstTextBlock* m_cComboParamsp = nullptr; // Combo function parameter list
AstTextBlock* m_cComboInsp = nullptr; // Combo input copy list
AstTextBlock* m_cComboOutsp = nullptr; // Combo output copy list
AstTextBlock* m_cSeqParamsp = nullptr; // Sequential parameter list
AstTextBlock* m_cSeqClksp = nullptr; // Sequential clock copy list
AstTextBlock* m_cSeqOutsp = nullptr; // Sequential output copy list
AstTextBlock* m_cIgnoreParamsp = nullptr; // Combo ignore parameter list
Add --lib-create, similar to --protect-lib but without protections (#3200).
2021-11-14 15:39:31 +01:00
const string m_libName;
const string m_topName;
C++11: Use member declaration initalizations. No functional change intended.
2020-08-15 19:11:27 +02:00
bool m_foundTop = false; // Have seen the top module
bool m_hasClk = false; // True if the top module has sequential logic
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// VISITORS
Remove redundant 'virtual' keywords from overridden methods 'virtual' is redundant when 'override' is present, so keep only 'override'. Add t/t_dist_cppstyle.pl to check for this.
2022-09-16 12:22:11 +02:00
void visit(AstNetlist* nodep) override {
clang-format remaining sources. No functional change.
2020-04-15 13:58:34 +02:00
m_vfilep
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
= new AstVFile{nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".sv"};
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
nodep->addFilesp(m_vfilep);
clang-format remaining sources. No functional change.
2020-04-15 13:58:34 +02:00
m_cfilep
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
= new AstCFile{nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".cpp"};
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
nodep->addFilesp(m_cfilep);
iterateChildren(nodep);
}
Remove redundant 'virtual' keywords from overridden methods 'virtual' is redundant when 'override' is present, so keep only 'override'. Add t/t_dist_cppstyle.pl to check for this.
2022-09-16 12:22:11 +02:00
void visit(AstNodeModule* nodep) override {
Fix overly aggressive --protect-lib check
2019-11-30 15:18:49 +01:00
if (!nodep->isTop()) {
return;
} else {
UASSERT_OBJ(!m_foundTop, nodep, "Multiple root modules");
}
Internals: Add more const. No functional change intended.
2021-11-13 19:50:44 +01:00
FileLine* const fl = nodep->fileline();
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
// Need to know the existence of clk before createSvFile()
m_hasClk = checkIfClockExists(nodep);
Add timescale directive for hier_block if the original design has it (#2554) * add timescale directive to a test to reproduce #2544 * add timescale directive to hierarchy blocks
2020-09-16 23:09:29 +02:00
createSvFile(fl, nodep);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
createCppFile(fl);
iterateChildren(nodep);
Internals: Fix remaining cppcheck errors (#6319) Fixed the non const-related issue and added suppressions for the const ones. With that `make cppcheck` should be clean.
2025-08-21 10:43:37 +02:00
// cppcheck-suppress unreadVariable
Internals: More const. No functional change intended.
2021-11-26 23:55:36 +01:00
const V3Hash hash = V3Hasher::uncachedHash(m_cfilep);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_hashValuep->add(cvtToStr(hash.value()) + ";\n");
m_cHashValuep->add(cvtToStr(hash.value()) + "U;\n");
Fix overly aggressive --protect-lib check
2019-11-30 15:18:49 +01:00
m_foundTop = true;
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
void addComment(AstTextBlock* txtp, FileLine* fl, const string& comment) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(new AstComment{fl, comment});
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
Improve hierarchical DPI wrapper scheduling performance (#2583) (#5734)
2025-01-20 20:24:09 +01:00
void configSection(AstNodeModule* modp, AstTextBlock* txtp, FileLine* fl) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("\n`ifdef VERILATOR\n");
txtp->add("`verilator_config\n");
Improve hierarchical DPI wrapper scheduling performance (#2583) (#5734)
2025-01-20 20:24:09 +01:00
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("profile_data -hier-dpi \"" + m_libName + "_protectlib_combo_update\" -cost 64'd"
+ std::to_string(v3Global.currentHierBlockCost()) + "\n");
txtp->add("profile_data -hier-dpi \"" + m_libName + "_protectlib_seq_update\" -cost 64'd"
+ std::to_string(v3Global.currentHierBlockCost()) + "\n");
Improve hierarchical DPI wrapper scheduling performance (#2583) (#5734)
2025-01-20 20:24:09 +01:00
Fix hierarchical `--prof-pgo` (#6213)
2025-09-13 16:19:00 +02:00
// Mark remaining NBA protectlib wrapper DPIs as non-hazardous by deliberately forwarding
Improve hierarchical DPI wrapper scheduling performance (#2583) (#5734)
2025-01-20 20:24:09 +01:00
// them with non-zero cost.
Support multi-thread hierarchical simulation (#2583) (#5871)
2025-03-24 23:39:29 +01:00
// Also, specify hierarchical workers for those tasks for scheduling.
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("profile_data -hier-dpi \"" + m_libName
+ "_protectlib_combo_ignore\" -cost 64'd1\n");
txtp->add("hier_workers -hier-dpi \"" + m_libName
+ "_protectlib_combo_update\" -workers 16'd"
+ std::to_string(V3Control::getHierWorkers(m_libName)) + "\n");
txtp->add("hier_workers -hier-dpi \"" + m_libName
+ "_protectlib_seq_update\" -workers 16'd"
+ std::to_string(V3Control::getHierWorkers(m_libName)) + "\n");
Support multi-thread hierarchical simulation (#2583) (#5871)
2025-03-24 23:39:29 +01:00
// No workers for combo_ignore
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("`verilog\n");
txtp->add("`endif\n");
Improve hierarchical DPI wrapper scheduling performance (#2583) (#5734)
2025-01-20 20:24:09 +01:00
}
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
void hashComment(AstTextBlock* txtp, FileLine* fl) {
addComment(txtp, fl, "Checks to make sure the .sv wrapper and library agree");
}
void initialComment(AstTextBlock* txtp, FileLine* fl) {
Internals: Add lib-create const and improve comments.
2021-11-14 18:01:02 +01:00
addComment(txtp, fl, "Creates an instance of the library module at initial-time");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
addComment(txtp, fl, "(one for each instance in the user's design) also evaluates");
Internals: Add lib-create const and improve comments.
2021-11-14 18:01:02 +01:00
addComment(txtp, fl, "the library module's initial process");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
void comboComment(AstTextBlock* txtp, FileLine* fl) {
addComment(txtp, fl, "Updates all non-clock inputs and retrieves the results");
}
void seqComment(AstTextBlock* txtp, FileLine* fl) {
addComment(txtp, fl, "Updates all clocks and retrieves the results");
}
void comboIgnoreComment(AstTextBlock* txtp, FileLine* fl) {
addComment(txtp, fl, "Need to convince some simulators that the input to the module");
addComment(txtp, fl, "must be evaluated before evaluating the clock edge");
}
void finalComment(AstTextBlock* txtp, FileLine* fl) {
Internals: Add lib-create const and improve comments.
2021-11-14 18:01:02 +01:00
addComment(txtp, fl, "Evaluates the library module's final process");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
Add timescale directive for hier_block if the original design has it (#2554) * add timescale directive to a test to reproduce #2544 * add timescale directive to hierarchy blocks
2020-09-16 23:09:29 +02:00
void createSvFile(FileLine* fl, AstNodeModule* modp) {
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Comments
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
AstTextBlock* const txtp = new AstTextBlock{fl};
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
addComment(txtp, fl, "Wrapper module for DPI protected library");
clang-format remaining sources. No functional change.
2020-04-15 13:58:34 +02:00
addComment(txtp, fl,
"This module requires lib" + m_libName + ".a or lib" + m_libName
+ ".so to work");
addComment(txtp, fl,
"See instructions in your simulator for how"
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
" to use DPI libraries\n");
// Module declaration
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_modPortsp = new AstTextBlock{fl, "module " + m_libName + " (\n", ", ", ");\n\n"};
txtp->add(m_modPortsp);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Support IEEE time units and time precisions, #234. (#2253) Includes `timescale, $printtimescale, $timeformat. VL_TIME_MULTIPLIER, VL_TIME_PRECISION, VL_TIME_UNIT have been removed and the time precision must now match the SystemC time precision. To get closer behavior to older versions, use e.g. --timescale-override "1ps/1ps".
2020-04-16 01:39:03 +02:00
// Timescale
Emit timescale in hierarchical block only when timescale is specified (#2735) * Add a test for hierarchical verilation without timescale * Emit timeunit in hierarchical wrapper only when it is specified in the input design or command line option. * Update src/V3AstNodes.h Co-authored-by: Wilson Snyder <wsnyder@wsnyder.org> Co-authored-by: Wilson Snyder <wsnyder@wsnyder.org>
2021-01-02 00:31:27 +01:00
if (v3Global.opt.hierChild() && v3Global.rootp()->timescaleSpecified()) {
Spelling fixes
2022-12-23 17:32:38 +01:00
// Emit timescale for hierarchical Verilation if input HDL specifies timespec
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("timeunit "s + modp->timeunit().ascii() + ";\n");
txtp->add("timeprecision "s + +v3Global.rootp()->timeprecision().ascii() + ";\n");
Emit timescale in hierarchical block only when timescale is specified (#2735) * Add a test for hierarchical verilation without timescale * Emit timeunit in hierarchical wrapper only when it is specified in the input design or command line option. * Update src/V3AstNodes.h Co-authored-by: Wilson Snyder <wsnyder@wsnyder.org> Co-authored-by: Wilson Snyder <wsnyder@wsnyder.org>
2021-01-02 00:31:27 +01:00
} else {
Add timescale directive for hier_block if the original design has it (#2554) * add timescale directive to a test to reproduce #2544 * add timescale directive to hierarchy blocks
2020-09-16 23:09:29 +02:00
addComment(txtp, fl,
"Precision of submodule"
" (commented out to avoid requiring timescale on all modules)");
Internals: Use C++14 quoted literal std::string
2024-01-29 02:24:28 +01:00
addComment(txtp, fl, "timeunit "s + v3Global.rootp()->timeunit().ascii() + ";");
Add timescale directive for hier_block if the original design has it (#2554) * add timescale directive to a test to reproduce #2544 * add timescale directive to hierarchy blocks
2020-09-16 23:09:29 +02:00
addComment(txtp, fl,
Internals: Use C++14 quoted literal std::string
2024-01-29 02:24:28 +01:00
"timeprecision "s + v3Global.rootp()->timeprecision().ascii() + ";\n");
Add timescale directive for hier_block if the original design has it (#2554) * add timescale directive to a test to reproduce #2544 * add timescale directive to hierarchy blocks
2020-09-16 23:09:29 +02:00
}
Support IEEE time units and time precisions, #234. (#2253) Includes `timescale, $printtimescale, $timeformat. VL_TIME_MULTIPLIER, VL_TIME_PRECISION, VL_TIME_UNIT have been removed and the time precision must now match the SystemC time precision. To get closer behavior to older versions, use e.g. --timescale-override "1ps/1ps".
2020-04-16 01:39:03 +02:00
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// DPI declarations
hashComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("import \"DPI-C\" function void " + m_libName
+ "_protectlib_check_hash(int protectlib_hash__V);\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
initialComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("import \"DPI-C\" function chandle " + m_libName
+ "_protectlib_create(string scope__V);\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
comboComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_comboPortsp = new AstTextBlock{fl, //
clang-format remaining sources. No functional change.
2020-04-15 13:58:34 +02:00
"import \"DPI-C\" function longint " + m_libName
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
+ "_protectlib_combo_update(\n", //
", ", //
");\n\n"};
m_comboPortsp->add("chandle handle__V\n");
txtp->add(m_comboPortsp);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
seqComment(txtp, fl);
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_seqPortsp = new AstTextBlock{fl, //
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
"import \"DPI-C\" function longint " + m_libName
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
+ "_protectlib_seq_update(\n", //
", ", //
");\n\n"};
m_seqPortsp->add("chandle handle__V\n");
txtp->add(m_seqPortsp);
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
comboIgnoreComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_comboIgnorePortsp = new AstTextBlock{fl, //
clang-format remaining sources. No functional change.
2020-04-15 13:58:34 +02:00
"import \"DPI-C\" function void " + m_libName
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
+ "_protectlib_combo_ignore(\n", //
", ", //
");\n\n"};
m_comboIgnorePortsp->add("chandle handle__V\n");
txtp->add(m_comboIgnorePortsp);
Internals: Add lib-create const and improve comments.
2021-11-14 18:01:02 +01:00
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
finalComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("import \"DPI-C\" function void " + m_libName
+ "_protectlib_final(chandle handle__V);\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Local variables
When using --lib-create, disable tracing hash/internals. Partial (#3200).
2021-11-14 16:16:59 +01:00
// Avoid tracing handle, as it is not a stable value, so breaks vcddiff
// Likewise other internals aren't interesting to the user
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("// verilator tracing_off\n");
When using --lib-create, disable tracing hash/internals. Partial (#3200).
2021-11-14 16:16:59 +01:00
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("chandle handle__V;\n");
txtp->add("time last_combo_seqnum__V;\n");
if (m_hasClk) txtp->add("time last_seq_seqnum__V;\n");
txtp->add("\n");
When using --lib-create, disable tracing hash/internals. Partial (#3200).
2021-11-14 16:16:59 +01:00
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
m_comboDeclsp = new AstTextBlock{fl};
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(m_comboDeclsp);
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
m_seqDeclsp = new AstTextBlock{fl};
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(m_seqDeclsp);
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
m_tmpDeclsp = new AstTextBlock{fl};
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(m_tmpDeclsp);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// CPP hash value
addComment(txtp, fl, "Hash value to make sure this file and the corresponding");
addComment(txtp, fl, "library agree");
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_hashValuep = new AstTextBlock{fl, "localparam int protectlib_hash__V = 32'd", "", "\n"};
txtp->add(m_hashValuep);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Initial
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("initial begin\n");
txtp->add(m_libName + "_protectlib_check_hash(protectlib_hash__V);\n");
txtp->add("handle__V = " + m_libName
+ "_protectlib_create"
"($sformatf(\"%m\"));\n");
txtp->add("end\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Combinatorial process
For hier-generated Verilog, use always_comb
2025-08-18 02:14:19 +02:00
addComment(txtp, fl, "Combinatorially evaluate changes to inputs");
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("always_comb begin\n");
m_comboParamsp = new AstTextBlock{fl, //
"last_combo_seqnum__V = " + m_libName
+ "_protectlib_combo_update(\n", //
",\n", //
"\n);\n"};
m_comboParamsp->add("handle__V");
txtp->add(m_comboParamsp);
txtp->add("end\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Sequential process
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
addComment(txtp, fl, "Evaluate clock edges");
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_clkSensp = new AstTextBlock{fl, "always @(", " or ", ")"};
txtp->add(m_clkSensp);
txtp->add(" begin\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
m_comboIgnoreParamsp
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
= new AstTextBlock{fl, //
m_libName + "_protectlib_combo_ignore(\n", ",\n", "\n);\n"};
m_comboIgnoreParamsp->add("handle__V");
txtp->add(m_comboIgnoreParamsp);
m_seqParamsp = new AstTextBlock{fl, //
"last_seq_seqnum__V <= " + m_libName
+ "_protectlib_seq_update(\n", //
",\n", //
"\n);\n"};
m_seqParamsp->add("handle__V");
txtp->add(m_seqParamsp);
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
m_nbAssignsp = new AstTextBlock{fl};
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(m_nbAssignsp);
txtp->add("end\n\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Select between combinatorial and sequential results
addComment(txtp, fl, "Select between combinatorial and sequential results");
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("always_comb begin\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("if (last_seq_seqnum__V > last_combo_seqnum__V) begin\n");
m_seqAssignsp = new AstTextBlock{fl};
txtp->add(m_seqAssignsp);
txtp->add("end else begin\n");
m_comboAssignsp = new AstTextBlock{fl};
txtp->add(m_comboAssignsp);
txtp->add("end\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
} else {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_comboAssignsp = new AstTextBlock{fl};
txtp->add(m_comboAssignsp);
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("end\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Final
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("final " + m_libName + "_protectlib_final(handle__V);\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("endmodule\n");
Improve hierarchical DPI wrapper scheduling performance (#2583) (#5734)
2025-01-20 20:24:09 +01:00
configSection(modp, txtp, fl);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
m_vfilep->tblockp(txtp);
}
void castPtr(FileLine* fl, AstTextBlock* txtp) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(m_topName
+ "_container* const handlep__V = " // LCOV_EXCL_LINE // lcov bug
"static_cast<"
+ m_topName + "_container*>(vhandlep__V);\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
void createCppFile(FileLine* fl) {
// Comments
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
AstTextBlock* const txtp = new AstTextBlock{fl};
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
addComment(txtp, fl, "Wrapper functions for DPI protected library\n");
// Includes
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("#include \"" + m_topName + ".h\"\n");
txtp->add("#include \"verilated_dpi.h\"\n\n");
txtp->add("#include <cstdio>\n");
txtp->add("#include <cstdlib>\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Verilated module plus sequence number
addComment(txtp, fl, "Container class to house verilated object and sequence number");
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("class " + m_topName + "_container: public " + m_topName + " {\n");
txtp->add("public:\n");
txtp->add("long long m_seqnum;\n");
txtp->add(m_topName + "_container(const char* scopep__V):\n");
txtp->add(m_topName + "(scopep__V) {}\n");
txtp->add("};\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Extern C
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("extern \"C\" {\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Hash check
hashComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("void " + m_libName
+ "_protectlib_check_hash"
"(int protectlib_hash__V) {\n");
m_cHashValuep = new AstTextBlock{fl, "const int expected_hash__V = ", "", ""};
txtp->add(m_cHashValuep);
txtp->add(/**/ "if (protectlib_hash__V != expected_hash__V) {\n");
txtp->add(/****/ "fprintf(stderr, \"%%Error: cannot use " + m_libName
+ " library, "
"Verliog (%u) and library (%u) hash values do not "
"agree\\n\", protectlib_hash__V, expected_hash__V);\n");
txtp->add(/****/ "std::exit(EXIT_FAILURE);\n");
txtp->add(/**/ "}\n");
txtp->add("}\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Initial
initialComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("void* " + m_libName + "_protectlib_create(const char* scopep__V) {\n");
txtp->add(/**/ m_topName + "_container* const handlep__V = new " + m_topName
+ "_container{scopep__V};\n");
txtp->add(/**/ "return handlep__V;\n");
txtp->add("}\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Updates
comboComment(txtp, fl);
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
m_cComboParamsp = new AstTextBlock{
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
fl, "long long " + m_libName + "_protectlib_combo_update(\n", ",\n", "\n) {\n"};
m_cComboParamsp->add("void* vhandlep__V");
txtp->add(m_cComboParamsp);
m_cComboInsp = new AstTextBlock{fl};
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
castPtr(fl, m_cComboInsp);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(m_cComboInsp);
txtp->add("handlep__V->eval();\n");
m_cComboOutsp = new AstTextBlock{fl};
txtp->add(m_cComboOutsp);
txtp->add("return handlep__V->m_seqnum++;\n");
txtp->add("}\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
seqComment(txtp, fl);
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
m_cSeqParamsp = new AstTextBlock{
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
fl, "long long " + m_libName + "_protectlib_seq_update(\n", ",\n", "\n) {\n"};
m_cSeqParamsp->add("void* vhandlep__V");
txtp->add(m_cSeqParamsp);
m_cSeqClksp = new AstTextBlock{fl};
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
castPtr(fl, m_cSeqClksp);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(m_cSeqClksp);
txtp->add("handlep__V->eval();\n");
m_cSeqOutsp = new AstTextBlock{fl};
txtp->add(m_cSeqOutsp);
txtp->add("return handlep__V->m_seqnum++;\n");
txtp->add("}\n\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
comboIgnoreComment(txtp, fl);
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
m_cIgnoreParamsp = new AstTextBlock{
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
fl, "void " + m_libName + "_protectlib_combo_ignore(\n", ",\n", "\n)\n{ }\n\n"};
m_cIgnoreParamsp->add("void* vhandlep__V");
txtp->add(m_cIgnoreParamsp);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
// Final
finalComment(txtp, fl);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("void " + m_libName + "_protectlib_final(void* vhandlep__V) {\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
castPtr(fl, txtp);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add(/**/ "handlep__V->final();\n");
txtp->add(/**/ "delete handlep__V;\n");
txtp->add("}\n\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
txtp->add("}\n");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
m_cfilep->tblockp(txtp);
}
Remove redundant 'virtual' keywords from overridden methods 'virtual' is redundant when 'override' is present, so keep only 'override'. Add t/t_dist_cppstyle.pl to check for this.
2022-09-16 12:22:11 +02:00
void visit(AstVar* nodep) override {
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
if (!nodep->isIO()) return;
if (nodep->direction() == VDirection::INPUT) {
Deprecate clocker attribute and --clk option (#6463) The only use for the clocker attribute and the AstVar::isUsedClock that is actually necessary today for correctness is to mark top level inputs of --lib-create blocks as being (or driving) a clock signal. Correctness of --lib-create (and hence hierarchical blocks) actually used to depend on having the right optimizations eliminate intermediate clocks (e.g.: V3Gate), when the top level port was not used directly in a sensitivity list, or marking top level signals manually via --clk or the clocker attribute. However V3Sched::partition already needs to trace through the logic to figure out what signals might drive a sensitivity list, so it can very easily mark all top level inputs as such. In this patch we remove the AstVar::attrClocker and AstVar::isUsedClock attributes, and replace them with AstVar::isPrimaryClock, automatically set by V3Sched::partition. This eliminates all need for manual annotation so we are deprecating the --clk/--no-clk options and the clocker/no_clocker attributes. This also eliminates the opportunity for any further mis-optimization similar to #6453. Regarding the other uses of the removed AstVar attributes: - As of 5.000, initial edges are triggered via a separate mechanism applied in V3Sched, so the use in V3EmitCFunc.cpp is redundant - Also as of 5.000, we can handle arbitrary sensitivity expressions, so the restriction on eliminating clock signals in V3Gate is unnecessary - Since the recent change when Dfg is applied after V3Scope, it does perform the equivalent of GateClkDecomp, so we can delete that pass.
2025-09-20 16:50:22 +02:00
if (nodep->isPrimaryClock()) {
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
UASSERT_OBJ(m_hasClk, nodep, "checkIfClockExists() didn't find this clock");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
handleClock(nodep);
} else {
handleDataInput(nodep);
}
} else if (nodep->direction() == VDirection::OUTPUT) {
handleOutput(nodep);
} else {
Add --lib-create, similar to --protect-lib but without protections (#3200).
2021-11-14 15:39:31 +01:00
nodep->v3warn(E_UNSUPPORTED, "Unsupported: --lib-create port direction: "
Add new UNSUPPORTED error code to replace most previous Unsupported: messages.
2020-06-10 01:20:16 +02:00
<< nodep->direction().ascii());
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
}
Remove redundant 'virtual' keywords from overridden methods 'virtual' is redundant when 'override' is present, so keep only 'override'. Add t/t_dist_cppstyle.pl to check for this.
2022-09-16 12:22:11 +02:00
void visit(AstNode*) override {}
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
string cInputConnection(AstVar* varp) {
Support unpacked array port in protect-lib and hierarchical verilation (#2672) * Add a test to use unpacked array port in hierarchical verilation and protect-lib. * V3EmitV supports unpacked array variables * Can Emit local unpacked array properly * Update golden of t_debug_emitv * Support unpacked array port in protect-lib * Remove t_prot_lib_unpacked_bad test as unpacked array is supported now.
2020-12-09 00:29:45 +01:00
return V3Task::assignDpiToInternal("handlep__V->" + varp->name(), varp);
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
void handleClock(AstVar* varp) {
handleInput(varp);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_seqPortsp->add(varp->cloneTree(false));
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
const std::string pname = varp->prettyName();
m_seqParamsp->add(pname);
Fix --lib-create with multi-bit clocks (#6759)
2025-12-05 16:21:35 +01:00
m_clkSensp->add(pname);
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_cSeqParamsp->add(varp->dpiArgType(true, false));
m_cSeqClksp->add(cInputConnection(varp));
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
void handleDataInput(AstVar* varp) {
handleInput(varp);
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_comboPortsp->add(varp->cloneTree(false));
m_comboParamsp->add(varp->prettyName());
m_comboIgnorePortsp->add(varp->cloneTree(false));
if (m_hasClk) m_comboIgnoreParamsp->add(varp->prettyName());
m_cComboParamsp->add(varp->dpiArgType(true, false));
m_cComboInsp->add(cInputConnection(varp));
m_cIgnoreParamsp->add(varp->dpiArgType(true, false));
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
void handleInput(AstVar* varp) { m_modPortsp->add(varp->cloneTree(false)); }
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Internals: Fix remaining cppcheck errors (#6319) Fixed the non const-related issue and added suppressions for the const ones. With that `make cppcheck` should be clean.
2025-08-21 10:43:37 +02:00
static void addLocalVariable(AstTextBlock* textp, const AstVar* varp, const char* suffix) {
Internals: Add more const. No functional change intended.
2021-11-13 19:50:44 +01:00
AstVar* const newVarp
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
= new AstVar{varp->fileline(), VVarType::VAR, varp->name() + suffix, varp->dtypep()};
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
textp->add(newVarp);
Support unpacked array port in protect-lib and hierarchical verilation (#2672) * Add a test to use unpacked array port in hierarchical verilation and protect-lib. * V3EmitV supports unpacked array variables * Can Emit local unpacked array properly * Update golden of t_debug_emitv * Support unpacked array port in protect-lib * Remove t_prot_lib_unpacked_bad test as unpacked array is supported now.
2020-12-09 00:29:45 +01:00
}
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
void handleOutput(AstVar* const varp) {
const std::string pname = varp->prettyName();
m_modPortsp->add(varp->cloneTree(false));
m_comboPortsp->add(varp->cloneTree(false));
m_comboParamsp->add(pname + "_combo__V");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_seqPortsp->add(varp->cloneTree(false));
m_seqParamsp->add(pname + "_tmp__V");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Support unpacked array port in protect-lib and hierarchical verilation (#2672) * Add a test to use unpacked array port in hierarchical verilation and protect-lib. * V3EmitV supports unpacked array variables * Can Emit local unpacked array properly * Update golden of t_debug_emitv * Support unpacked array port in protect-lib * Remove t_prot_lib_unpacked_bad test as unpacked array is supported now.
2020-12-09 00:29:45 +01:00
addLocalVariable(m_comboDeclsp, varp, "_combo__V");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
Support unpacked array port in protect-lib and hierarchical verilation (#2672) * Add a test to use unpacked array port in hierarchical verilation and protect-lib. * V3EmitV supports unpacked array variables * Can Emit local unpacked array properly * Update golden of t_debug_emitv * Support unpacked array port in protect-lib * Remove t_prot_lib_unpacked_bad test as unpacked array is supported now.
2020-12-09 00:29:45 +01:00
addLocalVariable(m_seqDeclsp, varp, "_seq__V");
addLocalVariable(m_tmpDeclsp, varp, "_tmp__V");
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_nbAssignsp->add(pname + "_seq__V <= " + pname + "_tmp__V;\n");
m_seqAssignsp->add(pname + " = " + pname + "_seq__V;\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_comboAssignsp->add(pname + " = " + pname + "_combo__V;\n");
m_cComboParamsp->add(varp->dpiArgType(true, false));
m_cComboOutsp->add(V3Task::assignInternalToDpi(varp, true, "", "", "handlep__V->") + "\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
if (m_hasClk) {
Internals: Refactor text based Ast constructs (#6280) (#6571) Remove the large variety of ways raw "text" is represented in the Ast. Particularly, the only thing that represents a string to be emitted in the output is AstText. There are 5 AstNodes that can contain AstText, and V3Emit will throw an error if an AstText is encountered anywhere else: - AstCStmt: Internally generated procedural statements involving raw text. - AstCStmtUser: This is the old AstUCStmt, renamed so it sorts next to AstCStmt, as it's largely equivalent. We should never create this internally unless used to represent user input. It is used for $c, statements in the input, and for some 'systemc_* blocks. - AstCExpr: Internally generaged expression involving raw text. - AstCExprUser: This is the old AstUCFunc, renamed so it sorts next to AstCExpr. It is largely equivalent, but also has more optimizations disabled. This should never be created internally, it is only used for $c expressions in the input. - AstTextBlock: Use by V3ProtectLib only, to generate the hierarchical wrappers. Text "tracking" for indentation is always on for AstCStmt, AstCExpr, and AstTextBlock, as these are always generated by us, and should always be well formed. Tracking is always off for AstCStmtUser and AstCExprUser, as these contain arbitrary user input that might not be safe to parse for indentation. Remove subsequently redundant AstNodeSimpleText and AstNodeText types. This patch also fixes incorrect indentation in emitted waveform tracing functions, and makes the output more readable for hier block SV stubs. With that, all raw text nodes are handled as a proper AstNodeStmt or AstNodeExpr as required for #6280.
2025-10-21 13:41:29 +02:00
m_cSeqParamsp->add(varp->dpiArgType(true, false));
m_cSeqOutsp->add(V3Task::assignInternalToDpi(varp, true, "", "", "handlep__V->")
+ "\n");
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
}
}
Internals: Fix remaining cppcheck errors (#6319) Fixed the non const-related issue and added suppressions for the const ones. With that `make cppcheck` should be clean.
2025-08-21 10:43:37 +02:00
static bool checkIfClockExists(const AstNodeModule* modp) {
for (const AstNode* stmtp = modp->stmtsp(); stmtp; stmtp = stmtp->nextp()) {
Internals: Add more const. No functional change intended.
2021-11-13 19:50:44 +01:00
if (const AstVar* const varp = VN_CAST(stmtp, Var)) {
Deprecate clocker attribute and --clk option (#6463) The only use for the clocker attribute and the AstVar::isUsedClock that is actually necessary today for correctness is to mark top level inputs of --lib-create blocks as being (or driving) a clock signal. Correctness of --lib-create (and hence hierarchical blocks) actually used to depend on having the right optimizations eliminate intermediate clocks (e.g.: V3Gate), when the top level port was not used directly in a sensitivity list, or marking top level signals manually via --clk or the clocker attribute. However V3Sched::partition already needs to trace through the logic to figure out what signals might drive a sensitivity list, so it can very easily mark all top level inputs as such. In this patch we remove the AstVar::attrClocker and AstVar::isUsedClock attributes, and replace them with AstVar::isPrimaryClock, automatically set by V3Sched::partition. This eliminates all need for manual annotation so we are deprecating the --clk/--no-clk options and the clocker/no_clocker attributes. This also eliminates the opportunity for any further mis-optimization similar to #6453. Regarding the other uses of the removed AstVar attributes: - As of 5.000, initial edges are triggered via a separate mechanism applied in V3Sched, so the use in V3EmitCFunc.cpp is redundant - Also as of 5.000, we can handle arbitrary sensitivity expressions, so the restriction on eliminating clock signals in V3Gate is unnecessary - Since the recent change when Dfg is applied after V3Scope, it does perform the equivalent of GateClkDecomp, so we can delete that pass.
2025-09-20 16:50:22 +02:00
if (varp->direction() == VDirection::INPUT && varp->isPrimaryClock()) {
Fix protect-lib without sequential logic (#2492) * add a test for protect-lib without sequential logic that cause the follwoing error. %Error: obj_vlt/t_prot_lib_comb/secret/secret.sv:78:14: syntax error, unexpected ')' 78 | always @() begin | ^ * protect-lib wrapper must contain sequential signal related statements only if the protected design is a sequential logic. Diff looks big, but actually just add "if (m_hasClk)" condition. Signed-off-by: Yutetsu TAKATSUKASA <y.takatsukasa@gmail.com>
2020-08-01 13:16:15 +02:00
return true;
}
}
}
return false;
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}
clang-format remaining sources. No functional change.
2020-04-15 13:58:34 +02:00
public:
explicit ProtectVisitor(AstNode* nodep)
Add --lib-create, similar to --protect-lib but without protections (#3200).
2021-11-14 15:39:31 +01:00
: m_libName{v3Global.opt.libCreate()}
C++11: Use member declaration initalizations. No functional change intended.
2020-08-16 15:55:36 +02:00
, m_topName{v3Global.opt.prefix()} {
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
iterate(nodep);
}
};
//######################################################################
// ProtectLib class functions
void V3ProtectLib::protect() {
Internals: UINFO now includes newline itself. No functional change.
2025-05-23 02:29:32 +02:00
UINFO(2, __FUNCTION__ << ":");
Internals: Cleanup constructors etc. No functional change.
2022-08-30 04:15:06 +02:00
ProtectVisitor{v3Global.rootp()};
Add --protect-lib to create protected libraries, bug1490.
2019-10-09 12:47:26 +02:00
}