github/verilator
1
0
Fork 1
mirror of https://github.com/verilator/verilator.git synced 2025-04-04 19:52:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement a distinct constant pool (#3013)

Browse Source 
What previously used to be per module static constants created in
V3Table and V3Prelim are now merged globally within the whole model and
emitted as part of a separate constant pool. Members of the constant
pool are global variables which are declared lazily when used (similar to
loose methods).
This commit is contained in:
Geza Lore 2021-06-13 15:05:55 +01:00 committed by GitHub
parent 60d5f0e86b
commit c207e98306
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
50 changed files with 1331 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Changes
View File

@ -18,6 +18,8 @@ Verilator 4.205 devel
**Minor:**
* Merge const static data globally into a new constant pool (#3013). [Geza Lore]
Verilator 4.204 2021-06-12

1
bin/verilator
View File

@ -344,6 +344,7 @@ detailed descriptions of these arguments.
--MMD Create .d dependency files
--MP Create phony dependency targets
--Mdir <directory> Name of output object directory
--no-merge-const-pool Disable merging of different types in const pool
--mod-prefix <topname> Name to prepend to lower classes
--no-clk <signal-name> Prevent marking specified signal as clock
--no-decoration Disable comments and symbol decorations

7
docs/guide/exe_verilator.rst
View File

@ -633,6 +633,13 @@ Summary:
The directory is created if it does not exist and the parent directories
exist; otherwise manually create the Mdir before calling Verilator.
.. option:: --no-merge-const-pool
Rarely needed. In order to minimize cache footprint, values of different
data type, that are yet emitted identically in C++ are merged in the
constant pool. This option disables this and causes every constant pool
entry with a distinct data type to be emitted separately.
.. option:: --mod-prefix <topname>
Specifies the name to prepend to all lower level classes. Defaults to

42
include/verilated_heavy.h
View File

@ -89,19 +89,24 @@ public:
};
//===================================================================
/// Verilog wide unpacked bit container.
/// Verilog wide packed bit container.
/// Similar to std::array<WData, N>, but lighter weight, only methods needed
/// by Verilator, to help compile time.
///
/// A 'struct' as we want this to be an aggregate type that allows
/// static aggregate initialization. Consider data members private.
///
/// For example a Verilog "bit [94:0]" will become a VlWide<3> because 3*32
/// bits are needed to hold the 95 bits. The MSB (bit 96) must always be
/// zero in memory, but during intermediate operations in the Verilated
/// internals is unpredictable.
template <std::size_t T_Words> class VlWide final {
EData m_storage[T_Words];
template <std::size_t T_Words> struct VlWide final {
// MEMBERS
// This should be the only data member, otherwise generated static initializers need updating
EData m_storage[T_Words]; // Contents of the packed array
public:
// CONSTRUCTORS
// cppcheck-suppress uninitVar
VlWide() = default;
~VlWide() = default;
@ -798,26 +803,21 @@ void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
}
//===================================================================
/// Verilog packed array container
/// Verilog unpacked array container
/// For when a standard C++[] array is not sufficient, e.g. an
/// array under a queue, or methods operating on the array.
///
/// A 'struct' as we want this to be an aggregate type that allows
/// static aggregate initialization. Consider data members private.
///
/// This class may get exposed to a Verilated Model's top I/O, if the top
/// IO has an unpacked array.
template <class T_Value, std::size_t T_Depth> class VlUnpacked final {
private:
// TYPES
using Array = std::array<T_Value, T_Depth>;
public:
using const_iterator = typename Array::const_iterator;
private:
template <class T_Value, std::size_t T_Depth> struct VlUnpacked final {
// MEMBERS
Array m_array; // Contents of the packed array
// This should be the only data member, otherwise generated static initializers need updating
T_Value m_storage[T_Depth]; // Contents of the unpacked array
public:
// CONSTRUCTORS
VlUnpacked() = default;
~VlUnpacked() = default;
@ -828,18 +828,18 @@ public:
// METHODS
// Raw access
WData* data() { return &m_array[0]; }
const WData* data() const { return &m_array[0]; }
WData* data() { return &m_storage[0]; }
const WData* data() const { return &m_storage[0]; }
T_Value& operator[](size_t index) { return m_array[index]; };
const T_Value& operator[](size_t index) const { return m_array[index]; };
T_Value& operator[](size_t index) { return m_storage[index]; };
const T_Value& operator[](size_t index) const { return m_storage[index]; };
// Dumping. Verilog: str = $sformatf("%p", assoc)
std::string to_string() const {
std::string out = "'{";
std::string comma;
for (int i = 0; i < T_Depth; ++i) {
out += comma + VL_TO_STRING(m_array[i]);
out += comma + VL_TO_STRING(m_storage[i]);
comma = ", ";
}
return out + "} ";

1
src/Makefile_obj.in
View File

@ -180,6 +180,7 @@ RAW_OBJS = \
V3Descope.o \
V3DupFinder.o \
V3EmitC.o \
V3EmitCConstPool.o \
V3EmitCInlines.o \
V3EmitCSyms.o \
V3EmitCMake.o \

126
src/V3AstNodes.cpp
View File

@ -18,16 +18,18 @@
#include "verilatedos.h"
#include "V3Ast.h"
#include "V3EmitCBase.h"
#include "V3File.h"
#include "V3Global.h"
#include "V3Graph.h"
#include "V3Hasher.h"
#include "V3PartitionGraph.h" // Just for mtask dumping
#include "V3String.h"
#include "V3EmitCBase.h"
#include "V3AstNodes__gen_macros.h" // Generated by 'astgen'
#include <iomanip>
#include <iterator>
#include <vector>
//======================================================================
@ -295,6 +297,14 @@ AstConst* AstConst::parseParamLiteral(FileLine* fl, const string& literal) {
return nullptr;
}
AstNetlist::AstNetlist()
: ASTGEN_SUPER_Netlist(new FileLine(FileLine::builtInFilename()))
, m_typeTablep{new AstTypeTable(fileline())}
, m_constPoolp{new AstConstPool(fileline())} {
addMiscsp(m_typeTablep);
addMiscsp(m_constPoolp);
}
void AstNetlist::timeprecisionMerge(FileLine*, const VTimescale& value) {
VTimescale prec = v3Global.opt.timeComputePrec(value);
if (prec.isNone() || prec == m_timeprecision) {
@ -899,6 +909,11 @@ bool AstSenTree::hasCombo() const {
return false;
}
AstTypeTable::AstTypeTable(FileLine* fl)
: ASTGEN_SUPER_TypeTable(fl) {
for (int i = 0; i < AstBasicDTypeKwd::_ENUM_MAX; ++i) m_basicps[i] = nullptr;
}
void AstTypeTable::clearCache() {
// When we mass-change widthMin in V3WidthCommit, we need to correct the table.
// Just clear out the maps; the search functions will be used to rebuild the map
@ -993,6 +1008,115 @@ AstBasicDType* AstTypeTable::findInsertSameDType(AstBasicDType* nodep) {
return nodep;
}
AstConstPool::AstConstPool(FileLine* fl)
: ASTGEN_SUPER_ConstPool(fl)
, m_modp{new AstModule(fl, "@CONST-POOL@")}
, m_scopep{new AstScope(fl, m_modp, "@CONST-POOL@", nullptr, nullptr)} {
addOp1p(m_modp);
m_modp->addStmtp(m_scopep);
}
AstVarScope* AstConstPool::createNewEntry(const string& name, AstNode* initp) {
FileLine* const fl = initp->fileline();
AstVar* const varp = new AstVar(fl, AstVarType::MODULETEMP, name, initp->dtypep());
varp->isConst(true);
varp->isStatic(true);
varp->valuep(initp->cloneTree(false));
m_modp->addStmtp(varp);
AstVarScope* const varScopep = new AstVarScope(fl, m_scopep, varp);
m_scopep->addVarp(varScopep);
return varScopep;
}
static bool sameInit(const AstInitArray* ap, const AstInitArray* bp) {
// Unpacked array initializers must have equivalent values
// Note, sadly we can't just call ap->sameTree(pb), because both:
// - the dtypes might be different instances
// - the default/inititem children might be in different order yet still yield the same table
// See note in AstInitArray::same about the same. This function instead compares by initializer
// value, rather than by tree structure.
const AstUnpackArrayDType* const aDTypep = VN_CAST(ap->dtypep(), UnpackArrayDType);
const AstUnpackArrayDType* const bDTypep = VN_CAST(bp->dtypep(), UnpackArrayDType);
UASSERT_STATIC(aDTypep, "Bad type in array initializer");
UASSERT_STATIC(bDTypep, "Bad type in array initializer");
if (!aDTypep->subDTypep()->sameTree(bDTypep->subDTypep())) { // Element types differ
return false;
}
if (!aDTypep->rangep()->sameTree(bDTypep->rangep())) { // Ranges differ
return false;
}
// Compare initializer arrays by value. Note this is only called when they hash the same,
// so they likely run at most once per call to 'AstConstPool::findTable'.
const uint32_t size = aDTypep->elementsConst();
for (uint32_t n = 0; n < size; ++n) {
const AstNode* const valAp = ap->getIndexDefaultedValuep(n);
const AstNode* const valBp = bp->getIndexDefaultedValuep(n);
if (!valAp->sameTree(valBp)) { return false; }
}
return true;
}
AstVarScope* AstConstPool::findTable(AstInitArray* initp) {
AstNode* const defaultp = initp->defaultp();
// Verify initializer is well formed
UASSERT_OBJ(VN_IS(initp->dtypep(), UnpackArrayDType), initp,
"Const pool table must have AstUnpackArrayDType dtype");
UASSERT_OBJ(!defaultp || VN_IS(defaultp, Const), initp,
"Const pool table default must be Const");
for (AstNode* nodep = initp->initsp(); nodep; nodep = nodep->nextp()) {
AstNode* const valuep = VN_CAST(nodep, InitItem)->valuep();
UASSERT_OBJ(VN_IS(valuep, Const), valuep, "Const pool table entry must be Const");
}
// Try to find an existing table with the same content
const uint32_t hash = V3Hasher::uncachedHash(initp).value();
const auto& er = m_tables.equal_range(hash);
for (auto it = er.first; it != er.second; ++it) {
AstVarScope* const varScopep = it->second;
const AstInitArray* const init2p = VN_CAST(varScopep->varp()->valuep(), InitArray);
if (sameInit(initp, init2p)) {
return varScopep; // Found identical table
}
}
// No such table yet, create it.
string name = "TABLE_";
name += cvtToHex(hash);
name += "_";
name += cvtToStr(std::distance(er.first, er.second));
AstVarScope* const varScopep = createNewEntry(name, initp);
m_tables.emplace(hash, varScopep);
return varScopep;
}
static bool sameInit(const AstConst* ap, const AstConst* bp) {
// Similarly to the AstInitArray comparison, we ignore the dtype instance, so long as they
// are compatible. For now, we assume the dtype is not relevant, as we only call this from
// V3Prelim which is a late pass.
// Compare initializers by value. This checks widths as well.
return ap->num().isCaseEq(bp->num());
}
AstVarScope* AstConstPool::findConst(AstConst* initp, bool mergeDType) {
// Try to find an existing constant with the same value
const uint32_t hash = initp->num().toHash().value();
const auto& er = m_consts.equal_range(hash);
for (auto it = er.first; it != er.second; ++it) {
AstVarScope* const varScopep = it->second;
const AstConst* const init2p = VN_CAST(varScopep->varp()->valuep(), Const);
if (sameInit(initp, init2p)
&& (mergeDType || varScopep->dtypep()->sameTree(initp->dtypep()))) {
return varScopep; // Found identical constant
}
}
// No such constant yet, create it.
string name = "CONST_";
name += cvtToHex(hash);
name += "_";
name += cvtToStr(std::distance(er.first, er.second));
AstVarScope* const varScopep = createNewEntry(name, initp);
m_consts.emplace(hash, varScopep);
return varScopep;
}
//======================================================================
// Special walking tree inserters

44
src/V3AstNodes.h
View File

@ -9082,10 +9082,7 @@ class AstTypeTable final : public AstNode {
DetailedMap m_detailedMap;
public:
explicit AstTypeTable(FileLine* fl)
: ASTGEN_SUPER_TypeTable(fl) {
for (int i = 0; i < AstBasicDTypeKwd::_ENUM_MAX; ++i) m_basicps[i] = nullptr;
}
explicit AstTypeTable(FileLine* fl);
ASTNODE_NODE_FUNCS(TypeTable)
AstNodeDType* typesp() const { return VN_CAST(op1p(), NodeDType); } // op1 = List of dtypes
void addTypesp(AstNodeDType* nodep) { addOp1p(nodep); }
@ -9102,6 +9099,34 @@ public:
virtual void dump(std::ostream& str = std::cout) const override;
};
class AstConstPool final : public AstNode {
// Container for const static data
std::unordered_multimap<uint32_t, AstVarScope*> m_tables; // Constant tables (unpacked arrays)
std::unordered_multimap<uint32_t, AstVarScope*> m_consts; // Constant tables (scalars)
AstModule* const m_modp; // The Module holding the Scope below ...
AstScope* const m_scopep; // Scope holding the constant variables
AstVarScope* createNewEntry(const string& name, AstNode* initp);
public:
explicit AstConstPool(FileLine* fl);
ASTNODE_NODE_FUNCS(ConstPool)
AstModule* modp() const { return m_modp; }
// Find a table (unpacked array) within the constant pool which is initialized with the
// given value, or create one if one does not already exists. The returned VarScope *might*
// have a different dtype than the given initp->dtypep(), including a different element type,
// but it will always have the same size and element width. In contexts where this matters,
// the caller must handle the dtype difference as appropriate.
AstVarScope* findTable(AstInitArray* initp);
// Find a constant within the constant pool which is initialized with the given value, or
// create one if one does not already exists. If 'mergeDType' is true, then the returned
// VarScope *might* have a different type than the given initp->dtypep(). In contexts where
// this matters, the caller must handle the dtype difference as appropriate. If 'mergeDType' is
// false, the returned VarScope will have _->dtypep()->sameTree(initp->dtypep()) return true.
AstVarScope* findConst(AstConst* initp, bool mergeDType);
};
//######################################################################
// Top
@ -9110,7 +9135,8 @@ class AstNetlist final : public AstNode {
// Parents: none
// Children: MODULEs & CFILEs
private:
AstTypeTable* m_typeTablep = nullptr; // Reference to top type table, for faster lookup
AstTypeTable* const m_typeTablep; // Reference to top type table, for faster lookup
AstConstPool* const m_constPoolp; // Reference to constant pool, for faster lookup
AstPackage* m_dollarUnitPkgp = nullptr; // $unit
AstCFunc* m_evalp = nullptr; // The '_eval' function
AstExecGraph* m_execGraphp = nullptr; // Execution MTask graph for threads>1 mode
@ -9118,8 +9144,7 @@ private:
VTimescale m_timeprecision; // Global time precision
bool m_timescaleSpecified = false; // Input HDL specified timescale
public:
AstNetlist()
: ASTGEN_SUPER_Netlist(new FileLine(FileLine::builtInFilename())) {}
AstNetlist();
ASTNODE_NODE_FUNCS(Netlist)
virtual const char* broken() const override {
BROKEN_RTN(m_dollarUnitPkgp && !m_dollarUnitPkgp->brokeExists());
@ -9140,10 +9165,7 @@ public:
AstNode* miscsp() const { return op3p(); } // op3 = List of dtypes etc
void addMiscsp(AstNode* nodep) { addOp3p(nodep); }
AstTypeTable* typeTablep() { return m_typeTablep; }
void addTypeTablep(AstTypeTable* nodep) {
m_typeTablep = nodep;
addMiscsp(nodep);
}
AstConstPool* constPoolp() { return m_constPoolp; }
AstPackage* dollarUnitPkgp() const { return m_dollarUnitPkgp; }
AstPackage* dollarUnitPkgAddp() {
if (!m_dollarUnitPkgp) {

27
src/V3EmitC.cpp
View File

@ -1131,7 +1131,10 @@ public:
// Terminals
virtual void visit(AstVarRef* nodep) override {
const AstVar* const varp = nodep->varp();
if (varp->isStatic()) {
if (isConstPoolMod(varp->user4p())) {
// Reference to constant pool variable
puts(topClassName() + "__ConstPool__");
} else if (varp->isStatic()) {
// Access static variable via the containing class
puts(prefixNameProtect(varp->user4p()) + "::");
} else if (!nodep->classPrefix().empty()) {
@ -1399,6 +1402,16 @@ class EmitCLazyDecls final : public AstNVisitor {
m_needsBlankLine = true;
}
void lazyDeclareConstPoolVar(AstVar* varp) {
if (varp->user2SetOnce()) return; // Already declared
const string nameProtect
= m_emitter.topClassName() + "__ConstPool__" + varp->nameProtect();
m_emitter.puts("extern const ");
m_emitter.puts(varp->dtypep()->cType(nameProtect, false, false));
m_emitter.puts(";\n");
m_needsBlankLine = true;
}
virtual void visit(AstNodeCCall* nodep) override {
lazyDeclare(nodep->funcp());
iterateChildren(nodep);
@ -1420,6 +1433,12 @@ class EmitCLazyDecls final : public AstNVisitor {
}
}
virtual void visit(AstVarRef* nodep) override {
AstVar* const varp = nodep->varp();
// Only constant pool symbols are lazy declared for now ...
if (EmitCBaseVisitor::isConstPoolMod(varp->user4p())) { lazyDeclareConstPoolVar(varp); }
}
virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
VL_DEBUG_FUNC;
@ -4108,11 +4127,15 @@ public:
static void setParentClassPointers() {
// Set user4p in all CFunc and Var to point to the containing AstNodeModule
for (AstNode* modp = v3Global.rootp()->modulesp(); modp; modp = modp->nextp()) {
auto setAll = [](AstNodeModule* modp) -> void {
for (AstNode* nodep = VN_CAST(modp, NodeModule)->stmtsp(); nodep; nodep = nodep->nextp()) {
if (VN_IS(nodep, CFunc) || VN_IS(nodep, Var)) nodep->user4p(modp);
}
};
for (AstNode* modp = v3Global.rootp()->modulesp(); modp; modp = modp->nextp()) {
setAll(VN_CAST(modp, NodeModule));
}
setAll(v3Global.rootp()->constPoolp()->modp());
}
void V3EmitC::emitc() {

1
src/V3EmitC.h
View File

@ -28,6 +28,7 @@
class V3EmitC final {
public:
static void emitc();
static void emitcConstPool();
static void emitcInlines();
static void emitcSyms(bool dpiHdrOnly = false);
static void emitcTrace();

5
src/V3EmitCBase.h
View File

@ -86,6 +86,11 @@ public:
static string topClassName() { // Return name of top wrapper module
return v3Global.opt.prefix();
}
static bool isConstPoolMod(AstNode* modp) {
return modp == v3Global.rootp()->constPoolp()->modp();
}
static AstCFile* newCFile(const string& filename, bool slow, bool source) {
AstCFile* cfilep = new AstCFile(v3Global.rootp()->fileline(), filename);
cfilep->slow(slow);

194
src/V3EmitCConstPool.cpp Normal file
View File

@ -0,0 +1,194 @@
// -*- mode: C++; c-file-style: "cc-mode" -*-
//*************************************************************************
// DESCRIPTION: Verilator: Emit C++ for tree
//
// Code available from: https://verilator.org
//
//*************************************************************************
//
// Copyright 2003-2021 by Wilson Snyder. This program is free software; you
// can redistribute it and/or modify it under the terms of either the GNU
// Lesser General Public License Version 3 or the Perl Artistic License
// Version 2.0.
// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
//
//*************************************************************************
#include "config_build.h"
#include "verilatedos.h"
#include "V3EmitC.h"
#include "V3EmitCBase.h"
#include "V3File.h"
#include "V3Global.h"
#include "V3String.h"
#include "V3Stats.h"
#include <algorithm>
#include <cinttypes>
//######################################################################
// Const pool emitter
class EmitCConstPool final : EmitCBaseVisitor {
// MEMBERS
bool m_inUnpacked = false;
uint32_t m_unpackedWord = 0;
uint32_t m_outFileCount = 0;
int m_outFileSize = 0;
VDouble0 m_tablesEmitted;
VDouble0 m_constsEmitted;
// METHODS
VL_DEBUG_FUNC; // Declare debug()
V3OutCFile* newOutCFile() const {
const string fileName = v3Global.opt.makeDir() + "/" + topClassName() + "__ConstPool_"
+ cvtToStr(m_outFileCount) + ".cpp";
newCFile(fileName, /* slow: */ true, /* source: */ true);
V3OutCFile* const ofp = new V3OutCFile(fileName);
ofp->putsHeader();
ofp->puts("// DESCRIPTION: Verilator output: Constant pool\n");
ofp->puts("//\n");
ofp->puts("\n");
ofp->puts("#include \"verilated_heavy.h\"\n");
return ofp;
}
void maybeSplitCFile() {
if (v3Global.opt.outputSplit() && m_outFileSize < v3Global.opt.outputSplit()) return;
// Splitting file, so using parallel build.
v3Global.useParallelBuild(true);
// Close current file
VL_DO_DANGLING(delete m_ofp, m_ofp);
// Open next file
m_outFileSize = 0;
++m_outFileCount;
m_ofp = newOutCFile();
}
void emitVars(const AstConstPool* poolp) {
std::vector<const AstVar*> varps;
for (AstNode* nodep = poolp->modp()->stmtsp(); nodep; nodep = nodep->nextp()) {
if (const AstVar* const varp = VN_CAST_CONST(nodep, Var)) { varps.push_back(varp); }
}
if (varps.empty()) return; // Constant pool is empty, so we are done
stable_sort(varps.begin(), varps.end(), [](const AstVar* ap, const AstVar* bp) { //
return ap->name() < bp->name();
});
m_ofp = newOutCFile();
for (const AstVar* varp : varps) {
maybeSplitCFile();
const string nameProtect = topClassName() + "__ConstPool__" + varp->nameProtect();
puts("\n");
puts("extern const ");
puts(varp->dtypep()->cType(nameProtect, false, false));
puts(" = ");
iterate(varp->valuep());
puts(";\n");
// Keep track of stats
if (VN_IS(varp->dtypep(), UnpackArrayDType)) {
++m_tablesEmitted;
} else {
++m_constsEmitted;
}
}
VL_DO_DANGLING(delete m_ofp, m_ofp);
}
// VISITORS
virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
virtual void visit(AstInitArray* nodep) override {
const AstUnpackArrayDType* const dtypep
= VN_CAST(nodep->dtypep()->skipRefp(), UnpackArrayDType);
UASSERT_OBJ(dtypep, nodep, "Array initializer has non-array dtype");
const uint32_t size = dtypep->elementsConst();
const uint32_t elemBytes = dtypep->subDTypep()->widthTotalBytes();
const uint32_t tabMod = dtypep->subDTypep()->isString()
? 1 // String
: elemBytes <= 2
? 8 // CData, SData
: elemBytes <= 4 ? 4 // IData
: elemBytes <= 8 ? 2 // QData
: 1;
VL_RESTORER(m_inUnpacked);
VL_RESTORER(m_unpackedWord);
m_inUnpacked = true;
// Note the double {{ initializer. The first { starts the initializer of the VlUnpacked,
// and the second starts the initializer of m_storage within the VlUnpacked.
puts("{");
ofp()->putsNoTracking("{");
puts("\n");
for (uint32_t n = 0; n < size; ++n) {
m_unpackedWord = n;
if (n) puts(n % tabMod ? ", " : ",\n");
iterate(nodep->getIndexDefaultedValuep(n));
}
puts("\n");
puts("}");
ofp()->putsNoTracking("}");
}
virtual void visit(AstInitItem* nodep) override { // LCOV_EXCL_START
nodep->v3fatal("Handled by AstInitArray");
} // LCOV_EXCL_END
virtual void visit(AstConst* nodep) override {
const V3Number& num = nodep->num();
UASSERT_OBJ(!num.isFourState(), nodep, "4-state value in constant pool");
AstNodeDType* const dtypep = nodep->dtypep();
m_outFileSize += 1;
if (num.isString()) {
// Note: putsQuoted does not track indentation, so we use this instead
puts("\"");
puts(num.toString());
puts("\"");
m_outFileSize += 9;
} else if (dtypep->isWide()) {
const uint32_t size = dtypep->widthWords();
m_outFileSize += size - 1;
// Note the double {{ initializer. The first { starts the initializer of the VlWide,
// and the second starts the initializer of m_storage within the VlWide.
puts("{");
ofp()->putsNoTracking("{");
if (m_inUnpacked) puts(" // VlWide " + cvtToStr(m_unpackedWord));
puts("\n");
for (uint32_t n = 0; n < size; ++n) {
if (n) puts(n % 4 ? ", " : ",\n");
ofp()->printf("0x%08" PRIx32, num.edataWord(n));
}
puts("\n");
puts("}");
ofp()->putsNoTracking("}");
} else if (dtypep->isQuad()) {
ofp()->printf("0x%016" PRIx64, static_cast<uint64_t>(num.toUQuad()));
} else if (dtypep->widthMin() > 16) {
ofp()->printf("0x%08" PRIx32, num.toUInt());
} else if (dtypep->widthMin() > 8) {
ofp()->printf("0x%04" PRIx32, num.toUInt());
} else {
ofp()->printf("0x%02" PRIx32, num.toUInt());
}
}
public:
explicit EmitCConstPool(AstConstPool* poolp) {
emitVars(poolp);
V3Stats::addStatSum("ConstPool, Tables emitted", m_tablesEmitted);
V3Stats::addStatSum("ConstPool, Constants emitted", m_constsEmitted);
}
};
//######################################################################
// EmitC static functions
void V3EmitC::emitcConstPool() {
UINFO(2, __FUNCTION__ << ": " << endl);
EmitCConstPool(v3Global.rootp()->constPoolp());
}

1
src/V3EmitCSyms.cpp
View File

@ -278,6 +278,7 @@ class EmitCSyms final : EmitCBaseVisitor {
if (!m_dpiHdrOnly) emitDpiImp();
}
}
virtual void visit(AstConstPool* nodep) override {} // Ignore
virtual void visit(AstNodeModule* nodep) override {
nameCheck(nodep);
VL_RESTORER(m_modp);

2
src/V3EmitXml.cpp
View File

@ -117,6 +117,7 @@ class EmitXmlFileVisitor final : public AstNVisitor {
iterateChildren(nodep);
puts("</netlist>\n");
}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
outputTag(nodep, "");
puts(" origName=");
@ -316,6 +317,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
if (nodep->level() >= 0
&& nodep->level() <= 2) { // ==2 because we don't add wrapper when in XML mode

6
src/V3Global.cpp
View File

@ -29,11 +29,7 @@
//######################################################################
// V3 Class -- top level
AstNetlist* V3Global::makeNetlist() {
AstNetlist* newp = new AstNetlist();
newp->addTypeTablep(new AstTypeTable(newp->fileline()));
return newp;
}
AstNetlist* V3Global::makeNetlist() { return new AstNetlist(); }
void V3Global::clear() {
#ifdef VL_LEAK_CHECK

2
src/V3Hash.h
View File

@ -31,7 +31,7 @@ public:
V3Hash()
: m_value{0} {}
explicit V3Hash(uint32_t val)
: m_value{val + 0x9e3779b9} {} // This is the same as 'V3Hash() + val'
: m_value{val} {}
explicit V3Hash(int32_t val)
: m_value{static_cast<uint32_t>(val)} {}
explicit V3Hash(size_t val)

12
src/V3Hasher.cpp
View File

@ -351,7 +351,17 @@ private:
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstInitArray* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
// Hash unpacked array initializers by value, as the order of initializer nodes does not
// matter, and we want semantically equivalent initializers to map to the same hash.
AstUnpackArrayDType* const dtypep = VN_CAST(nodep->dtypep(), UnpackArrayDType);
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, /* hashChildren: */ !dtypep, [=]() {
if (dtypep) {
const uint32_t size = dtypep->elementsConst();
for (uint32_t n = 0; n < size; ++n) { //
iterateNull(nodep->getIndexDefaultedValuep(n));
}
}
});
}
virtual void visit(AstPragma* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //

1
src/V3LinkCells.cpp
View File

@ -193,6 +193,7 @@ private:
<< "' was not found in design.");
}
}
virtual void visit(AstConstPool* nodep) override {}
virtual void visit(AstNodeModule* nodep) override {
// Module: Pick up modnames, so we can resolve cells later
VL_RESTORER(m_modp);

4
src/V3LinkDot.cpp
View File

@ -770,6 +770,7 @@ class LinkDotFindVisitor final : public AstNVisitor {
}
}
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
// Called on top module from Netlist, other modules from the cell creating them,
// and packages
@ -1364,6 +1365,7 @@ private:
// VISITs
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
UINFO(5, " " << nodep << endl);
if (nodep->dead() || !nodep->user4()) {
@ -1530,6 +1532,7 @@ class LinkDotScopeVisitor final : public AstNVisitor {
// Recurse..., backward as must do packages before using packages
iterateChildrenBackwards(nodep);
}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstScope* nodep) override {
UINFO(8, " SCOPE " << nodep << endl);
UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
@ -1925,6 +1928,7 @@ private:
iterateChildrenBackwards(nodep);
}
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
if (nodep->dead()) return;
checkNoDot(nodep);

1
src/V3Options.cpp
View File

@ -1141,6 +1141,7 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc, char
}
});
DECL_OPTION("-max-num-width", Set, &m_maxNumWidth);
DECL_OPTION("-merge-const-pool", OnOff, &m_mergeConstPool);
DECL_OPTION("-mod-prefix", Set, &m_modPrefix);
DECL_OPTION("-O", CbPartialMatch, [this](const char* optp) {

2
src/V3Options.h
View File

@ -246,6 +246,7 @@ private:
bool m_lintOnly = false; // main switch: --lint-only
bool m_gmake = false; // main switch: --make gmake
bool m_main = false; // main swithc: --main
bool m_mergeConstPool = true; // main switch: --merge-const-pool
bool m_orderClockDly = true; // main switch: --order-clock-delay
bool m_outFormatOk = false; // main switch: --cc, --sc or --sp was specified
bool m_pedantic = false; // main switch: --Wpedantic
@ -454,6 +455,7 @@ public:
bool traceStructs() const { return m_traceStructs; }
bool traceUnderscore() const { return m_traceUnderscore; }
bool main() const { return m_main; }
bool mergeConstPool() const { return m_mergeConstPool; }
bool orderClockDly() const { return m_orderClockDly; }
bool outFormatOk() const { return m_outFormatOk; }
bool keepTempFiles() const { return (V3Error::debugDefault() != 0); }

79
src/V3Premit.cpp
View File

@ -92,11 +92,9 @@ private:
// AstNodeMath::user() -> bool. True if iterated already
// AstShiftL::user2() -> bool. True if converted to conditional
// AstShiftR::user2() -> bool. True if converted to conditional
// AstConst::user2p() -> Replacement static variable pointer
// *::user4() -> See PremitAssignVisitor
AstUser1InUse m_inuser1;
AstUser2InUse m_inuser2;
// AstUser4InUse part of V3Hasher via V3DupFinder
// STATE
AstNodeModule* m_modp = nullptr; // Current module
@ -106,10 +104,7 @@ private:
AstTraceInc* m_inTracep = nullptr; // Inside while loop, special statement additions
bool m_assignLhs = false; // Inside assignment lhs, don't breakup extracts
V3DupFinder m_dupFinder; // Duplicate finder for static constants that can be reused
VDouble0 m_staticConstantsExtracted; // Statistic tracking
VDouble0 m_staticConstantsReused; // Statistic tracking
VDouble0 m_extractedToConstPool; // Statistic tracking
// METHODS
VL_DEBUG_FUNC; // Declare debug()
@ -170,71 +165,48 @@ private:
}
void createDeepTemp(AstNode* nodep, bool noSubst) {
if (nodep->user1()) return;
if (debug() > 8) nodep->dumpTree(cout, "deepin:");
if (nodep->user1SetOnce()) return; // Only add another assignment for this node
AstNRelinker linker;
nodep->unlinkFrBack(&linker);
AstNRelinker relinker;
nodep->unlinkFrBack(&relinker);
FileLine* const fl = nodep->fileline();
AstVar* varp = nullptr;
AstConst* const constp = VN_CAST(nodep, Const);
const bool useStatic = constp && (constp->width() >= STATIC_CONST_MIN_WIDTH)
&& !constp->num().isFourState();
if (useStatic) {
// Extract as static constant
const auto& it = m_dupFinder.findDuplicate(constp);
if (it == m_dupFinder.end()) {
const string newvarname = string("__Vconst") + cvtToStr(m_modp->varNumGetInc());
varp = new AstVar(nodep->fileline(), AstVarType::MODULETEMP, newvarname,
nodep->dtypep());
varp->isConst(true);
varp->isStatic(true);
varp->valuep(constp);
m_modp->addStmtp(varp);
m_dupFinder.insert(constp);
nodep->user2p(varp);
++m_staticConstantsExtracted;
} else {
varp = VN_CAST(it->second->user2p(), Var);
++m_staticConstantsReused;
}
const bool useConstPool = constp // Is a constant
&& (constp->width() >= STATIC_CONST_MIN_WIDTH) // Large enough
&& !constp->num().isFourState() // Not four state
&& !constp->num().isString(); // Not a string
if (useConstPool) {
// Extract into constant pool.
const bool merge = v3Global.opt.mergeConstPool();
varp = v3Global.rootp()->constPoolp()->findConst(constp, merge)->varp();
nodep->deleteTree();
++m_extractedToConstPool;
} else {
// Keep as local temporary
const string newvarname = string("__Vtemp") + cvtToStr(m_modp->varNumGetInc());
varp
= new AstVar(nodep->fileline(), AstVarType::STMTTEMP, newvarname, nodep->dtypep());
const string name = string("__Vtemp") + cvtToStr(m_modp->varNumGetInc());
varp = new AstVar(fl, AstVarType::STMTTEMP, name, nodep->dtypep());
m_cfuncp->addInitsp(varp);
}
if (noSubst) varp->noSubst(true); // Do not remove varrefs to this in V3Const
// Replace node tree with reference to var
AstVarRef* newp = new AstVarRef(nodep->fileline(), varp, VAccess::READ);
linker.relink(newp);
if (!useStatic) {
// Put assignment before the referencing statement
AstAssign* assp = new AstAssign(
nodep->fileline(), new AstVarRef(nodep->fileline(), varp, VAccess::WRITE), nodep);
insertBeforeStmt(assp);
if (debug() > 8) assp->dumpTree(cout, "deepou:");
insertBeforeStmt(new AstAssign(fl, new AstVarRef(fl, varp, VAccess::WRITE), nodep));
}
nodep->user1(true); // Don't add another assignment
// Do not remove VarRefs to this in V3Const
if (noSubst) varp->noSubst(true);
// Replace node with VarRef to new Var
relinker.relink(new AstVarRef(fl, varp, VAccess::READ));
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
UASSERT_OBJ(m_modp == nullptr, nodep, "Nested modules ?");
UASSERT_OBJ(m_dupFinder.empty(), nodep, "Statements outside module ?");
m_modp = nodep;
m_cfuncp = nullptr;
iterateChildren(nodep);
m_modp = nullptr;
m_dupFinder.clear();
}
virtual void visit(AstCFunc* nodep) override {
VL_RESTORER(m_cfuncp);
@ -442,9 +414,8 @@ public:
// CONSTRUCTORS
explicit PremitVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~PremitVisitor() {
V3Stats::addStat("Optimizations, Prelim static constants extracted",
m_staticConstantsExtracted);
V3Stats::addStat("Optimizations, Prelim static constants reused", m_staticConstantsReused);
V3Stats::addStat("Optimizations, Prelim extracted value to ConstPool",
m_extractedToConstPool);
}
};

11
src/V3String.h
View File

@ -22,9 +22,11 @@
// No V3 headers here - this is a base class for Vlc etc
#include <iomanip>
#include <map>
#include <sstream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>
@ -36,11 +38,18 @@ template <class T> std::string cvtToStr(const T& t) {
os << t;
return os.str();
}
template <class T> std::string cvtToHex(const T* tp) {
template <class T>
typename std::enable_if<std::is_pointer<T>::value, std::string>::type cvtToHex(const T tp) {
std::ostringstream os;
os << static_cast<const void*>(tp);
return os.str();
}
template <class T>
typename std::enable_if<std::is_integral<T>::value, std::string>::type cvtToHex(const T t) {
std::ostringstream os;
os << std::hex << std::setw(sizeof(T) * 8 / 4) << std::setfill('0') << t;
return os.str();
}
inline uint32_t cvtToHash(const void* vp) {
// We can shove a 64 bit pointer into a 32 bit bucket

417
src/V3Table.cpp
View File

@ -38,11 +38,15 @@
// CONFIG
// 1MB is max table size (better be lots of instructs to be worth it!)
static const double TABLE_MAX_BYTES = 1 * 1024 * 1024;
static constexpr int TABLE_MAX_BYTES = 1 * 1024 * 1024;
// 64MB is close to max memory of some systems (256MB or so), so don't get out of control
static const double TABLE_TOTAL_BYTES = 64 * 1024 * 1024;
static const double TABLE_SPACE_TIME_MULT = 8; // Worth 8 bytes of data to replace a instruction
static const int TABLE_MIN_NODE_COUNT = 32; // If < 32 instructions, not worth the effort
static constexpr int TABLE_TOTAL_BYTES = 64 * 1024 * 1024;
// Worth no more than 8 bytes of data to replace an instruction
static constexpr int TABLE_SPACE_TIME_MULT = 8;
// If < 32 instructions, not worth the effort
static constexpr int TABLE_MIN_NODE_COUNT = 32;
// Assume an instruction is 4 bytes
static constexpr int TABLE_BYTES_PER_INST = 4;
//######################################################################
@ -62,6 +66,81 @@ public:
virtual ~TableSimulateVisitor() override = default;
};
//######################################################################
// Class for holding lookup table state during construction
class TableBuilder final {
FileLine* const m_fl; // FileLine used during construction
AstInitArray* m_initp = nullptr; // The lookup table initializer values
AstVarScope* m_varScopep = nullptr; // The scoped variable holding the table
public:
explicit TableBuilder(FileLine* fl)
: m_fl{fl} {}
~TableBuilder() {
if (m_initp) m_initp->deleteTree();
}
void setTableSize(AstNodeDType* elemDType, unsigned size) {
UASSERT_OBJ(!m_initp, m_fl, "Table size already set");
UASSERT_OBJ(size > 0, m_fl, "Size zero");
// TODO: Assert elemDType is a packed type
// Create data type
const int width = elemDType->width();
AstNodeDType* const subDTypep
= elemDType->isString()
? elemDType
: v3Global.rootp()->findBitDType(width, width, VSigning::UNSIGNED);
AstUnpackArrayDType* const tableDTypep
= new AstUnpackArrayDType(m_fl, subDTypep, new AstRange(m_fl, size, 0));
v3Global.rootp()->typeTablep()->addTypesp(tableDTypep);
// Create table initializer (with default value 0)
AstConst* const defaultp = elemDType->isString()
? new AstConst(m_fl, AstConst::String(), "")
: new AstConst(m_fl, AstConst::WidthedValue(), width, 0);
m_initp = new AstInitArray(m_fl, tableDTypep, defaultp);
}
void addValue(unsigned index, const V3Number& value) {
UASSERT_OBJ(!m_varScopep, m_fl, "Table variable already created");
// Default value is zero/empty string so don't add it
if (value.isString() ? value.toString().empty() : value.isEqZero()) return;
m_initp->addIndexValuep(index, new AstConst(m_fl, value));
}
AstVarScope* varScopep() {
if (!m_varScopep) { m_varScopep = v3Global.rootp()->constPoolp()->findTable(m_initp); }
return m_varScopep;
}
};
//######################################################################
// Class for holding output variable state during table conversion of logic
class TableOutputVar final {
AstVarScope* const m_varScopep; // The output variable
const unsigned m_ord; // Output ordinal number in this block
bool m_mayBeUnassigned = false; // If true, then this variable may be unassigned through
// some path through the block being table converted
TableBuilder m_tableBuilder;
public:
TableOutputVar(AstVarScope* varScopep, unsigned ord)
: m_varScopep{varScopep}
, m_ord{ord}
, m_tableBuilder{varScopep->fileline()} {}
AstVarScope* varScopep() const { return m_varScopep; }
string name() const { return varScopep()->varp()->name(); }
unsigned ord() const { return m_ord; }
void setMayBeUnassigned() { m_mayBeUnassigned = true; }
bool mayBeUnassigned() const { return m_mayBeUnassigned; }
void setTableSize(unsigned size) { m_tableBuilder.setTableSize(varScopep()->dtypep(), size); }
void addValue(unsigned index, const V3Number& value) { m_tableBuilder.addValue(index, value); }
AstVarScope* tabeVarScopep() { return m_tableBuilder.varScopep(); }
};
//######################################################################
// Table class functions
@ -84,44 +163,54 @@ private:
// State cleared on each always/assignw
bool m_assignDly = false; // Consists of delayed assignments instead of normal assignments
int m_inWidth = 0; // Input table width
int m_outWidth = 0; // Output table width
unsigned m_inWidthBits = 0; // Input table width - in bits
unsigned m_outWidthBytes = 0; // Output table width - in bytes
std::deque<AstVarScope*> m_inVarps; // Input variable list
std::deque<AstVarScope*> m_outVarps; // Output variable list
std::deque<bool> m_outNotSet; // True if output variable is not set at some point
// When creating a table
std::deque<AstVarScope*> m_tableVarps; // Table being created
std::vector<TableOutputVar> m_outVarps; // Output variable list
// METHODS
VL_DEBUG_FUNC; // Declare debug()
public:
void simulateVarRefCb(AstVarRef* nodep) {
// Called by TableSimulateVisitor on each unique varref encountered
UINFO(9, " SimVARREF " << nodep << endl);
AstVarScope* vscp = nodep->varScopep();
if (nodep->access().isWriteOrRW()) {
// We'll make the table with a separate natural alignment for each output var, so
// always have 8, 16 or 32 bit widths, so use widthTotalBytes
m_outWidthBytes += nodep->varp()->dtypeSkipRefp()->widthTotalBytes();
m_outVarps.emplace_back(vscp, m_outVarps.size());
}
if (nodep->access().isReadOrRW()) {
m_inWidthBits += nodep->varp()->width();
m_inVarps.push_back(vscp);
}
}
private:
bool treeTest(AstAlways* nodep) {
// Process alw/assign tree
m_inWidth = 0;
m_outWidth = 0;
m_inWidthBits = 0;
m_outWidthBytes = 0;
m_inVarps.clear();
m_outVarps.clear();
m_outNotSet.clear();
// Collect stats
TableSimulateVisitor chkvis(this);
chkvis.mainTableCheck(nodep);
m_assignDly = chkvis.isAssignDly();
// Also sets m_inWidth
// Also sets m_outWidth
// Also sets m_inWidthBits
// Also sets m_outWidthBytes
// Also sets m_inVarps
// Also sets m_outVarps
// Calc data storage in bytes
size_t chgWidth = m_outVarps.size(); // Width of one change-it-vector
if (chgWidth < 8) chgWidth = 8;
double space = (std::pow(static_cast<double>(2.0), static_cast<double>(m_inWidth))
* static_cast<double>(m_outWidth + chgWidth));
const size_t chgWidth = m_outVarps.size();
const double space = std::pow<double>(2.0, m_inWidthBits) * (m_outWidthBytes + chgWidth);
// Instruction count bytes (ok, it's space also not time :)
double bytesPerInst = 4;
double time = ((chkvis.instrCount() * bytesPerInst + chkvis.dataCount())
+ 1); // +1 so won't div by zero
const double time // max(_, 1), so we won't divide by zero
= std::max<double>(chkvis.instrCount() * TABLE_BYTES_PER_INST + chkvis.dataCount(), 1);
if (chkvis.instrCount() < TABLE_MIN_NODE_COUNT) {
chkvis.clearOptimizable(nodep, "Table has too few nodes involved");
}
@ -134,13 +223,13 @@ private:
if (m_totalBytes > TABLE_TOTAL_BYTES) {
chkvis.clearOptimizable(nodep, "Table out of memory");
}
if (!m_outWidth || !m_inWidth) { //
if (!m_outWidthBytes || !m_inWidthBits) {
chkvis.clearOptimizable(nodep, "Table has no outputs");
}
UINFO(4, " Test: Opt=" << (chkvis.optimizable() ? "OK" : "NO")
<< ", Instrs=" << chkvis.instrCount()
<< " Data=" << chkvis.dataCount() << " inw=" << m_inWidth
<< " outw=" << m_outWidth << " Spacetime=" << (space / time) << "("
UINFO(4, " Test: Opt=" << (chkvis.optimizable() ? "OK" : "NO") << ", Instrs="
<< chkvis.instrCount() << " Data=" << chkvis.dataCount()
<< " in width (bits)=" << m_inWidthBits << " out width (bytes)="
<< m_outWidthBytes << " Spacetime=" << (space / time) << "("
<< space << "/" << time << ")"
<< ": " << nodep << endl);
if (chkvis.optimizable()) {
@ -150,135 +239,51 @@ private:
return chkvis.optimizable();
}
public:
void simulateVarRefCb(AstVarRef* nodep) {
// Called by TableSimulateVisitor on each unique varref encountered
UINFO(9, " SimVARREF " << nodep << endl);
AstVarScope* vscp = nodep->varScopep();
if (nodep->access().isWriteOrRW()) {
m_outWidth += nodep->varp()->dtypeSkipRefp()->widthTotalBytes();
m_outVarps.push_back(vscp);
}
if (nodep->access().isReadOrRW()) {
// We'll make the table with a separate natural alignment for each
// output var, so always have char, 16 or 32 bit widths, so use widthTotalBytes
m_inWidth += nodep->varp()->width(); // Space for var
m_inVarps.push_back(vscp);
}
}
private:
void createTable(AstAlways* nodep) {
void replaceWithTable(AstAlways* nodep) {
// We've determined this table of nodes is optimizable, do it.
++m_modTables;
++m_statTablesCre;
// Index into our table
AstVar* indexVarp
= new AstVar(nodep->fileline(), AstVarType::BLOCKTEMP,
"__Vtableidx" + cvtToStr(m_modTables), VFlagBitPacked(), m_inWidth);
FileLine* const fl = nodep->fileline();
// We will need a table index variable, create it here.
AstVar* const indexVarp
= new AstVar(fl, AstVarType::BLOCKTEMP, "__Vtableidx" + cvtToStr(m_modTables),
VFlagBitPacked(), m_inWidthBits);
m_modp->addStmtp(indexVarp);
AstVarScope* indexVscp = new AstVarScope(indexVarp->fileline(), m_scopep, indexVarp);
AstVarScope* const indexVscp = new AstVarScope(indexVarp->fileline(), m_scopep, indexVarp);
m_scopep->addVarp(indexVscp);
// Change it variable
FileLine* fl = nodep->fileline();
AstNodeArrayDType* dtypep = new AstUnpackArrayDType(
fl, nodep->findBitDType(m_outVarps.size(), m_outVarps.size(), VSigning::UNSIGNED),
new AstRange(fl, VL_MASK_I(m_inWidth), 0));
v3Global.rootp()->typeTablep()->addTypesp(dtypep);
AstVar* chgVarp = new AstVar(fl, AstVarType::MODULETEMP,
"__Vtablechg" + cvtToStr(m_modTables), dtypep);
chgVarp->isConst(true);
chgVarp->valuep(new AstInitArray(nodep->fileline(), dtypep, nullptr));
m_modp->addStmtp(chgVarp);
AstVarScope* chgVscp = new AstVarScope(chgVarp->fileline(), m_scopep, chgVarp);
m_scopep->addVarp(chgVscp);
// The 'output assigned' table builder
TableBuilder outputAssignedTableBuilder(fl);
outputAssignedTableBuilder.setTableSize(
nodep->findBitDType(m_outVarps.size(), m_outVarps.size(), VSigning::UNSIGNED),
VL_MASK_I(m_inWidthBits));
createTableVars(nodep);
AstNode* stmtsp = createLookupInput(nodep, indexVscp);
createTableValues(nodep, chgVscp);
// Set sizes of output tables
for (TableOutputVar& tov : m_outVarps) { tov.setTableSize(VL_MASK_I(m_inWidthBits)); }
// Collapse duplicate tables
chgVscp = findDuplicateTable(chgVscp);
for (auto& vscp : m_tableVarps) vscp = findDuplicateTable(vscp);
// Populate the tables
createTables(nodep, outputAssignedTableBuilder);
createOutputAssigns(nodep, stmtsp, indexVscp, chgVscp);
AstNode* stmtsp = createLookupInput(fl, indexVscp);
createOutputAssigns(nodep, stmtsp, indexVscp, outputAssignedTableBuilder.varScopep());
// Link it in.
if (AstAlways* nodeap = VN_CAST(nodep, Always)) {
// Keep sensitivity list, but delete all else
nodeap->bodysp()->unlinkFrBackWithNext()->deleteTree();
nodeap->addStmtp(stmtsp);
if (debug() >= 6) nodeap->dumpTree(cout, " table_new: ");
} else { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Creating table under unknown node type");
}
// Cleanup internal structures
m_tableVarps.clear();
// Keep sensitivity list, but delete all else
nodep->bodysp()->unlinkFrBackWithNext()->deleteTree();
nodep->addStmtp(stmtsp);
if (debug() >= 6) nodep->dumpTree(cout, " table_new: ");
}
void createTableVars(AstNode* nodep) {
// Create table for each output
std::map<const std::string, int> namecounts;
for (const AstVarScope* outvscp : m_outVarps) {
AstVar* outvarp = outvscp->varp();
FileLine* fl = nodep->fileline();
AstNodeArrayDType* dtypep = new AstUnpackArrayDType(
fl, outvarp->dtypep(), new AstRange(fl, VL_MASK_I(m_inWidth), 0));
v3Global.rootp()->typeTablep()->addTypesp(dtypep);
string name = "__Vtable" + cvtToStr(m_modTables) + "_" + outvarp->name();
const auto nit = namecounts.find(name);
if (nit != namecounts.end()) {
// Multiple scopes can have same var name. We could append the
// scope name but that is very long, so just deduplicate.
name += "__dedup" + cvtToStr(++nit->second);
} else {
namecounts[name] = 0;
}
AstVar* tablevarp = new AstVar(fl, AstVarType::MODULETEMP, name, dtypep);
tablevarp->isConst(true);
tablevarp->isStatic(true);
tablevarp->valuep(new AstInitArray(nodep->fileline(), dtypep, nullptr));
m_modp->addStmtp(tablevarp);
AstVarScope* tablevscp = new AstVarScope(tablevarp->fileline(), m_scopep, tablevarp);
m_scopep->addVarp(tablevscp);
m_tableVarps.push_back(tablevscp);
}
}
AstNode* createLookupInput(AstNode* nodep, AstVarScope* indexVscp) {
// Concat inputs into a single temp variable (inside always)
// First var in inVars becomes the LSB of the concat
AstNode* concatp = nullptr;
for (AstVarScope* invscp : m_inVarps) {
AstVarRef* refp = new AstVarRef(nodep->fileline(), invscp, VAccess::READ);
if (concatp) {
concatp = new AstConcat(nodep->fileline(), refp, concatp);
} else {
concatp = refp;
}
}
AstNode* stmtsp
= new AstAssign(nodep->fileline(),
new AstVarRef(nodep->fileline(), indexVscp, VAccess::WRITE), concatp);
return stmtsp;
}
void createTableValues(AstAlways* nodep, AstVarScope* chgVscp) {
void createTables(AstAlways* nodep, TableBuilder& outputAssignedTableBuilder) {
// Create table
// There may be a simulation path by which the output doesn't change value.
// We could bail on these cases, or we can have a "change it" boolean.
// We've chosen the latter route, since recirc is common in large FSMs.
for (std::deque<AstVarScope*>::iterator it = m_outVarps.begin(); it != m_outVarps.end();
++it) {
m_outNotSet.push_back(false);
}
uint32_t inValueNextInitArray = 0;
TableSimulateVisitor simvis(this);
for (uint32_t inValue = 0; inValue <= VL_MASK_I(m_inWidth); inValue++) {
for (uint32_t i = 0; i <= VL_MASK_I(m_inWidthBits); ++i) {
const uint32_t inValue = i;
// Make a new simulation structure so we can set new input values
UINFO(8, " Simulating " << std::hex << inValue << endl);
@ -290,12 +295,12 @@ private:
uint32_t shift = 0;
for (AstVarScope* invscp : m_inVarps) {
// LSB is first variable, so extract it that way
AstConst cnst(invscp->fileline(), AstConst::WidthedValue(), invscp->width(),
VL_MASK_I(invscp->width()) & (inValue >> shift));
const AstConst cnst(invscp->fileline(), AstConst::WidthedValue(), invscp->width(),
VL_MASK_I(invscp->width()) & (inValue >> shift));
simvis.newValue(invscp, &cnst);
shift += invscp->width();
// We're just using32 bit arithmetic, because there's no
// way the input table can be 2^32 bytes!
// We are using 32 bit arithmetic, because there's no way the input table can be
// 2^32 bytes!
UASSERT_OBJ(shift <= 32, nodep, "shift overflow");
UINFO(8, " Input " << invscp->name() << " = " << cnst.name() << endl);
}
@ -306,104 +311,72 @@ private:
"Optimizable cleared, even though earlier test run said not: "
<< simvis.whyNotMessage());
// If a output changed, add it to table
int outnum = 0;
V3Number outputChgMask(nodep, m_outVarps.size(), 0);
for (AstVarScope* outvscp : m_outVarps) {
V3Number* outnump = simvis.fetchOutNumberNull(outvscp);
AstNode* setp;
if (!outnump) {
UINFO(8, " Output " << outvscp->name() << " never set\n");
m_outNotSet[outnum] = true;
// Value in table is arbitrary, but we need something
setp = new AstConst(outvscp->fileline(), AstConst::WidthedValue(),
outvscp->width(), 0);
// Build output value tables and the assigned flags table
V3Number outputAssignedMask(nodep, m_outVarps.size(), 0);
for (TableOutputVar& tov : m_outVarps) {
if (V3Number* const outnump = simvis.fetchOutNumberNull(tov.varScopep())) {
UINFO(8, " Output " << tov.name() << " = " << *outnump << endl);
outputAssignedMask.setBit(tov.ord(), 1); // Mark output as assigned
tov.addValue(inValue, *outnump);
} else {
UINFO(8, " Output " << outvscp->name() << " = " << *outnump << endl);
// m_tableVarps[inValue] = num;
// Mark changed bit, too
outputChgMask.setBit(outnum, 1);
setp = new AstConst(outnump->fileline(), *outnump);
UINFO(8, " Output " << tov.name() << " not set for this input\n");
tov.setMayBeUnassigned();
}
// Note InitArray requires us to have the values in inValue order
VN_CAST(m_tableVarps[outnum]->varp()->valuep(), InitArray)->addValuep(setp);
outnum++;
}
{ // Set changed table
UASSERT_OBJ(inValue == inValueNextInitArray, nodep,
"InitArray requires us to have the values in inValue order");
inValueNextInitArray++;
AstNode* setp = new AstConst(nodep->fileline(), outputChgMask);
VN_CAST(chgVscp->varp()->valuep(), InitArray)->addValuep(setp);
}
// Set changed table
outputAssignedTableBuilder.addValue(inValue, outputAssignedMask);
} // each value
}
AstVarScope* findDuplicateTable(AstVarScope* vsc1p) {
// See if another table we've created is identical, if so use it for both.
// (A more 'modern' way would be to instead use V3DupFinder::findDuplicate)
AstVar* var1p = vsc1p->varp();
for (AstVarScope* vsc2p : m_modTableVscs) {
AstVar* var2p = vsc2p->varp();
if (var1p->width() == var2p->width()
&& (var1p->dtypep()->arrayUnpackedElements()
== var2p->dtypep()->arrayUnpackedElements())) {
const AstNode* init1p = VN_CAST(var1p->valuep(), InitArray);
const AstNode* init2p = VN_CAST(var2p->valuep(), InitArray);
if (init1p->sameGateTree(init2p)) {
UINFO(8, " Duplicate table var " << vsc2p << " == " << vsc1p << endl);
VL_DO_DANGLING(vsc1p->unlinkFrBack()->deleteTree(), vsc1p);
return vsc2p;
}
AstNode* createLookupInput(FileLine* fl, AstVarScope* indexVscp) {
// Concat inputs into a single temp variable (inside always)
// First var in inVars becomes the LSB of the concat
AstNode* concatp = nullptr;
for (AstVarScope* invscp : m_inVarps) {
AstVarRef* refp = new AstVarRef(fl, invscp, VAccess::READ);
if (concatp) {
concatp = new AstConcat(fl, refp, concatp);
} else {
concatp = refp;
}
}
m_modTableVscs.push_back(vsc1p);
return vsc1p;
return new AstAssign(fl, new AstVarRef(fl, indexVscp, VAccess::WRITE), concatp);
}
AstArraySel* select(FileLine* fl, AstVarScope* fromp, AstVarScope* indexp) {
AstVarRef* const fromRefp = new AstVarRef(fl, fromp, VAccess::READ);
AstVarRef* const indexRefp = new AstVarRef(fl, indexp, VAccess::READ);
return new AstArraySel(fl, fromRefp, indexRefp);
}
void createOutputAssigns(AstNode* nodep, AstNode* stmtsp, AstVarScope* indexVscp,
AstVarScope* chgVscp) {
// We walk through the changemask table, and if all ones know
// the output is set on all branches and therefore eliminate the
// if. If all uses of the changemask disappear, dead code
// elimination will remove it for us.
// Set each output from array ref into our table
int outnum = 0;
for (AstVarScope* outvscp : m_outVarps) {
AstNode* alhsp = new AstVarRef(nodep->fileline(), outvscp, VAccess::WRITE);
AstNode* arhsp = new AstArraySel(
nodep->fileline(),
new AstVarRef(nodep->fileline(), m_tableVarps[outnum], VAccess::READ),
new AstVarRef(nodep->fileline(), indexVscp, VAccess::READ));
AstNode* outasnp
= (m_assignDly
? static_cast<AstNode*>(new AstAssignDly(nodep->fileline(), alhsp, arhsp))
: static_cast<AstNode*>(new AstAssign(nodep->fileline(), alhsp, arhsp)));
AstNode* outsetp = outasnp;
AstVarScope* outputAssignedTableVscp) {
FileLine* const fl = nodep->fileline();
for (TableOutputVar& tov : m_outVarps) {
AstNode* const alhsp = new AstVarRef(fl, tov.varScopep(), VAccess::WRITE);
AstNode* const arhsp = select(fl, tov.tabeVarScopep(), indexVscp);
AstNode* outsetp = m_assignDly
? static_cast<AstNode*>(new AstAssignDly(fl, alhsp, arhsp))
: static_cast<AstNode*>(new AstAssign(fl, alhsp, arhsp));
// Is the value set in only some branches of the table?
if (m_outNotSet[outnum]) {
// If this output is unassigned on some code paths, wrap the assignment in an If
if (tov.mayBeUnassigned()) {
V3Number outputChgMask(nodep, m_outVarps.size(), 0);
outputChgMask.setBit(outnum, 1);
outsetp = new AstIf(
nodep->fileline(),
new AstAnd(nodep->fileline(),
new AstArraySel(
nodep->fileline(),
new AstVarRef(nodep->fileline(), chgVscp, VAccess::READ),
new AstVarRef(nodep->fileline(), indexVscp, VAccess::READ)),
new AstConst(nodep->fileline(), outputChgMask)),
outsetp, nullptr);
outputChgMask.setBit(tov.ord(), 1);
AstNode* const condp
= new AstAnd(fl, select(fl, outputAssignedTableVscp, indexVscp),
new AstConst(fl, outputChgMask));
outsetp = new AstIf(fl, condp, outsetp, nullptr);
}
stmtsp->addNext(outsetp);
outnum++;
}
}
// VISITORS
virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
VL_RESTORER(m_modTables);
@ -425,16 +398,14 @@ private:
UINFO(4, " ALWAYS " << nodep << endl);
if (treeTest(nodep)) {
// Well, then, I'll be a memory hog.
VL_DO_DANGLING(createTable(nodep), nodep);
replaceWithTable(nodep);
}
}
virtual void visit(AstAssignAlias*) override {}
virtual void visit(AstAssignW* nodep) override {
virtual void visit(AstNodeAssign* nodep) override {
// It's nearly impossible to have a large enough assign to make this worthwhile
// For now we won't bother.
// Accelerated: no iterate
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

3
src/Verilator.cpp
View File

@ -439,7 +439,7 @@ static void process() {
// Make all math operations either 8, 16, 32 or 64 bits
V3Clean::cleanAll(v3Global.rootp());
// Move wide constants to BLOCK temps.
// Move wide constants to BLOCK temps / ConstPool.
V3Premit::premitAll(v3Global.rootp());
}
@ -499,6 +499,7 @@ static void process() {
// emitcInlines is first, as it may set needHInlines which other emitters read
V3EmitC::emitcInlines();
V3EmitC::emitcSyms();
V3EmitC::emitcConstPool();
V3EmitC::emitcTrace();
} else if (v3Global.opt.dpiHdrOnly()) {
V3EmitC::emitcSyms(true);

9
test_regress/t/t_extract_static_const.pl
View File

@ -19,12 +19,11 @@ execute(
expect_filename => $Self->{golden_filename},
);
if ($Self->{vlt}) {
# Note, with vltmt this might be split differently, so only checking vlt
file_grep($Self->{stats}, qr/Optimizations, Prelim static constants extracted\s+(\d+)/i,
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Prelim extracted value to ConstPool\s+(\d+)/i,
8);
file_grep($Self->{stats}, qr/ConstPool, Constants emitted\s+(\d+)/i,
1);
file_grep($Self->{stats}, qr/Optimizations, Prelim static constants reused\s+(\d+)/i,
7);
}
ok(1);

34
test_regress/t/t_extract_static_const.v
View File

@ -6,25 +6,35 @@
module t (/*AUTOARG*/);
wire [255:0] C = {32'h1111_1111,
32'h2222_2222,
32'h3333_3333,
32'h4444_4444,
32'h5555_5555,
32'h6666_6666,
32'h7777_7777,
32'h8888_8888};
wire bit [255:0] C = {32'h1111_1111,
32'h2222_2222,
32'h3333_3333,
32'h4444_4444,
32'h5555_5555,
32'h6666_6666,
32'h7777_7777,
32'h8888_8888};
// Same values as above, but with different type
wire logic [255:0] D = {32'h1111_1111,
32'h2222_2222,
32'h3333_3333,
32'h4444_4444,
32'h5555_5555,
32'h6666_6666,
32'h7777_7777,
32'h8888_8888};
initial begin
// Note: Base index via $c to prevent optimizatoin by Verilator
$display("0x%32x", C[$c(0*32)+:32]);
$display("0x%32x", C[$c(1*32)+:32]);
$display("0x%32x", D[$c(1*32)+:32]);
$display("0x%32x", C[$c(2*32)+:32]);
$display("0x%32x", C[$c(3*32)+:32]);
$display("0x%32x", D[$c(3*32)+:32]);
$display("0x%32x", C[$c(4*32)+:32]);
$display("0x%32x", C[$c(5*32)+:32]);
$display("0x%32x", D[$c(5*32)+:32]);
$display("0x%32x", C[$c(6*32)+:32]);
$display("0x%32x", C[$c(7*32)+:32]);
$display("0x%32x", D[$c(7*32)+:32]);
$write("*-* All Finished *-*\n");
$finish;
end

11
test_regress/t/t_extract_static_const_multimodule.pl
View File

@ -19,12 +19,11 @@ execute(
expect_filename => $Self->{golden_filename},
);
if ($Self->{vlt}) {
# Note, with vltmt this might be split differently, so only checking vlt
file_grep($Self->{stats}, qr/Optimizations, Prelim static constants extracted\s+(\d+)/i,
2);
file_grep($Self->{stats}, qr/Optimizations, Prelim static constants reused\s+(\d+)/i,
6);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Prelim extracted value to ConstPool\s+(\d+)/i,
8);
file_grep($Self->{stats}, qr/ConstPool, Constants emitted\s+(\d+)/i,
1);
}
ok(1);

33
test_regress/t/t_extract_static_const_no_merge.pl Executable file
View File

@ -0,0 +1,33 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you can
# redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(vlt_all => 1);
top_filename("t/t_extract_static_const.v");
golden_filename("t/t_extract_static_const.out");
compile(
verilator_flags2 => ["--stats", "--no-merge-const-pool"],
);
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Prelim extracted value to ConstPool\s+(\d+)/i,
8);
file_grep($Self->{stats}, qr/ConstPool, Constants emitted\s+(\d+)/i,
2);
}
ok(1);
1;

9
test_regress/t/t_opt_table_enum.out Normal file
View File

@ -0,0 +1,9 @@
cyle 0 = 0
cyle 1 = 1
cyle 2 = 2
cyle 3 = 99
cyle 4 = 4
cyle 5 = 5
cyle 6 = 99
cyle 7 = 99
*-* All Finished *-*

28
test_regress/t/t_opt_table_enum.pl Executable file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
compile(
verilator_flags2 => ["--stats"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 1);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 1);
}
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;

45
test_regress/t/t_opt_table_enum.v Normal file
View File

@ -0,0 +1,45 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (/*AUTOARG*/
// Inputs
clk
);
input clk;
enum {
CASE_0 = 0,
CASE_1 = 1,
CASE_2 = 2,
CASE_4 = 4,
CASE_5 = 5,
DEFAULT = 99
} e;
reg [2:0] cyc;
initial cyc = 0;
always @(posedge clk) cyc <= cyc + 1;
always @* begin
case (cyc)
3'b000: e = CASE_0;
3'b001: e = CASE_1;
3'b010: e = CASE_2;
3'b100: e = CASE_4;
3'b101: e = CASE_5;
default: e = DEFAULT;
endcase
end
always @(posedge clk) begin
$display("cyle %d = %d", cyc, e);
if (cyc == 7) begin
$write("*-* All Finished *-*\n");
$finish;
end
end
endmodule

9
test_regress/t/t_opt_table_packed_array.out Normal file
View File

@ -0,0 +1,9 @@
cyle 0 = { 3, 2, 1, 0 }
cyle 1 = { 4, 3, 2, 1 }
cyle 2 = { 5, 4, 3, 4 }
cyle 3 = { 15, 15, 15, 15 }
cyle 4 = { 7, 6, 5, 4 }
cyle 5 = { 8, 7, 6, 5 }
cyle 6 = { 15, 15, 15, 15 }
cyle 7 = { 15, 15, 15, 15 }
*-* All Finished *-*

28
test_regress/t/t_opt_table_packed_array.pl Executable file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
compile(
verilator_flags2 => ["--stats"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 1);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 1);
}
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;

38
test_regress/t/t_opt_table_packed_array.v Normal file
View File

@ -0,0 +1,38 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (/*AUTOARG*/
// Inputs
clk
);
input clk;
logic [3:0][3:0] a;
reg [2:0] cyc;
initial cyc = 0;
always @(posedge clk) cyc <= cyc + 1;
always @* begin
case (cyc)
3'b000: a = {4'd0, 4'd1, 4'd2, 4'd3};
3'b001: a = {4'd1, 4'd2, 4'd3, 4'd4};
3'b010: a = {4'd4, 4'd3, 4'd4, 4'd5};
3'b100: a = {4'd4, 4'd5, 4'd6, 4'd7};
3'b101: a = {4'd5, 4'd6, 4'd7, 4'd8};
default: a = {4{4'hf}};
endcase
end
always @(posedge clk) begin
$display("cyle %d = { %d, %d, %d, %d }", cyc, a[0], a[1], a[2], a[3]);
if (cyc == 7) begin
$write("*-* All Finished *-*\n");
$finish;
end
end
endmodule

9
test_regress/t/t_opt_table_same.out Normal file
View File

@ -0,0 +1,9 @@
cyle 0 = 0 0
cyle 1 = 1 1
cyle 2 = 2 2
cyle 3 = 99 99
cyle 4 = 4 4
cyle 5 = 5 5
cyle 6 = 99 99
cyle 7 = 99 99
*-* All Finished *-*

28
test_regress/t/t_opt_table_same.pl Executable file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
compile(
verilator_flags2 => ["--stats"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 2);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 1);
}
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;

51
test_regress/t/t_opt_table_same.v Normal file
View File

@ -0,0 +1,51 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (/*AUTOARG*/
// Inputs
clk
);
input clk;
int i;
int j;
reg [2:0] cyc;
initial cyc = 0;
always @(posedge clk) cyc <= cyc + 1;
always @* begin
case (cyc)
3'b000: i = 0;
3'b001: i = 1;
3'b010: i = 2;
3'b100: i = 4;
3'b101: i = 5;
default: i = 99;
endcase
end
// Equivalent to above
always @* begin
case (cyc)
3'b101: j = 5;
3'b100: j = 4;
3'b010: j = 2;
3'b001: j = 1;
3'b000: j = 0;
default: j = 99;
endcase
end
always @(posedge clk) begin
$display("cyle %d = %d %d", cyc, i, j);
if (cyc == 7) begin
$write("*-* All Finished *-*\n");
$finish;
end
end
endmodule

9
test_regress/t/t_opt_table_signed.out Normal file
View File

@ -0,0 +1,9 @@
cyle 0 = 0
cyle 1 = -1
cyle 2 = 2
cyle 3 = -2147483648
cyle 4 = -4
cyle 5 = 5
cyle 6 = -2147483648
cyle 7 = -2147483648
*-* All Finished *-*

28
test_regress/t/t_opt_table_signed.pl Executable file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
compile(
verilator_flags2 => ["--stats"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 1);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 1);
}
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;

38
test_regress/t/t_opt_table_signed.v Normal file
View File

@ -0,0 +1,38 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (/*AUTOARG*/
// Inputs
clk
);
input clk;
int i;
reg [2:0] cyc;
initial cyc = 0;
always @(posedge clk) cyc <= cyc + 1;
always @* begin
case (cyc)
3'b000: i = 0;
3'b001: i = -1;
3'b010: i = 2;
3'b100: i = -4;
3'b101: i = 5;
default: i = -1 << 31;
endcase
end
always @(posedge clk) begin
$display("cyle %d = %d", cyc, i);
if (cyc == 7) begin
$write("*-* All Finished *-*\n");
$finish;
end
end
endmodule

9
test_regress/t/t_opt_table_sparse.out Normal file
View File

@ -0,0 +1,9 @@
cyle 0 = 0
cyle 1 = 1
cyle 2 = 1
cyle 3 = 99
cyle 4 = 4
cyle 5 = 5
cyle 6 = 99
cyle 7 = 99
*-* All Finished *-*

28
test_regress/t/t_opt_table_sparse.pl Executable file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
compile(
verilator_flags2 => ["--stats"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 1);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 2);
}
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;

40
test_regress/t/t_opt_table_sparse.v Normal file
View File

@ -0,0 +1,40 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (/*AUTOARG*/
// Inputs
clk
);
input clk;
int i;
reg [2:0] cyc;
initial cyc = 0;
always @(posedge clk) cyc <= cyc + 1;
/* verilator lint_off LATCH */
always @* begin
case (cyc)
3'b000: i = 0;
3'b001: i = 1;
3'b010: ; // unset
3'b100: i = 4;
3'b101: i = 5;
default: i = 99;
endcase
end
/* verilator lint_on LATCH */
always @(posedge clk) begin
$display("cyle %d = %d", cyc, i);
if (cyc == 7) begin
$write("*-* All Finished *-*\n");
$finish;
end
end
endmodule

47
test_regress/t/t_opt_table_sparse_output_split.pl Executable file
View File

@ -0,0 +1,47 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
top_filename("t/t_opt_table_sparse.v");
golden_filename("t/t_opt_table_sparse.out");
compile(
verilator_flags2 => ["--stats", "--output-split 1"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 1);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 2);
}
# Splitting should set VM_PARALLEL_BUILDS to 1 by default
file_grep("$Self->{obj_dir}/$Self->{VM_PREFIX}_classes.mk", qr/VM_PARALLEL_BUILDS\s*=\s*1/);
check_splits(2);
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;
sub check_splits {
my $expected = shift;
my $n;
foreach my $file (glob("$Self->{obj_dir}/*.cpp")) {
if ($file =~ /__ConstPool_/) {
$n += 1;
}
}
$n == $expected or error("__ConstPool*.cpp not split: $n");
}

9
test_regress/t/t_opt_table_string.out Normal file
View File

@ -0,0 +1,9 @@
cyle 0 = case-0
cyle 1 = case-1
cyle 2 = case-2
cyle 3 = default
cyle 4 = case-4
cyle 5 = case-5
cyle 6 = default
cyle 7 = default
*-* All Finished *-*

28
test_regress/t/t_opt_table_string.pl Executable file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
compile(
verilator_flags2 => ["--stats"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 1);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 1);
}
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;

37
test_regress/t/t_opt_table_string.v Normal file
View File

@ -0,0 +1,37 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (/*AUTOARG*/
// Inputs
clk
);
input clk;
string s;
reg [2:0] cyc;
initial cyc = 0;
always @(posedge clk) cyc <= cyc + 1;
always @* begin
case (cyc)
3'b000: s = "case-0";
3'b001: s = "case-1";
3'b010: s = "case-2";
3'b100: s = "case-4";
3'b101: s = "case-5";
default: s = "default";
endcase
end
always @(posedge clk) begin
$display("cyle %d = %s", cyc, s);
if (cyc == 7) begin
$write("*-* All Finished *-*\n");
$finish;
end
end
endmodule

9
test_regress/t/t_opt_table_struct.out Normal file
View File

@ -0,0 +1,9 @@
cyle 0 = { 0, 1, 2 }
cyle 1 = { 1, 2, 3 }
cyle 2 = { 2, 3, 4 }
cyle 3 = { 0, 0, 0 }
cyle 4 = { 4, 5, 6 }
cyle 5 = { 5, 6, 7 }
cyle 6 = { 0, 0, 0 }
cyle 7 = { 0, 0, 0 }
*-* All Finished *-*

28
test_regress/t/t_opt_table_struct.pl Executable file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2003 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(simulator => 1);
compile(
verilator_flags2 => ["--stats"],
);
if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Tables created\s+(\d+)/i, 1);
file_grep($Self->{stats}, qr/ConstPool, Tables emitted\s+(\d+)/i, 1);
}
execute(
check_finished => 1,
expect_filename => $Self->{golden_filename},
);
ok(1);
1;

42
test_regress/t/t_opt_table_struct.v Normal file
View File

@ -0,0 +1,42 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (/*AUTOARG*/
// Inputs
clk
);
input clk;
struct packed {
bit [31:0] a;
bit [15:0] b;
bit [ 7:0] c;
} s;
reg [2:0] cyc;
initial cyc = 0;
always @(posedge clk) cyc <= cyc + 1;
always @* begin
case (cyc)
3'b000: s = {32'd0, 16'd1, 8'd2};
3'b001: s = {32'd1, 16'd2, 8'd3};
3'b010: s = {32'd2, 16'd3, 8'd4};
3'b100: s = {32'd4, 16'd5, 8'd6};
3'b101: s = {32'd5, 16'd6, 8'd7};
default: s = '0;
endcase
end
always @(posedge clk) begin
$display("cyle %d = { %d, %d, %d }", cyc, s.a, s.b, s.c);
if (cyc == 7) begin
$write("*-* All Finished *-*\n");
$finish;
end
end
endmodule