Spelling fixes
git-svn-id: file://localhost/svn/verilator/trunk/verilator@973 77ca24e4-aefa-0310-84f0-b9a241c72d87
This commit is contained in:
Wilson Snyder
parent
6412aff82d
commit
a94f1c779b
|
|
@ -411,7 +411,7 @@ change the SystemC modules instantiated.
|
|||
=item --inline-mult I<value>
|
||||
|
||||
Tune the inlining of modules. The default value of 2000 specifies that up
|
||||
to 2000 new operations may be added to the model by inlining, if more then
|
||||
to 2000 new operations may be added to the model by inlining, if more than
|
||||
this number of operations would result, the module is not inlined. Larger
|
||||
values, or a value <= 1 will inline everything, will lead to longer compile
|
||||
times, but potentially faster runtimes. This setting is ignored for very
|
||||
|
|
@ -573,7 +573,7 @@ Disable all lint related warning messages. This is equivelent to
|
|||
-Wno-IMPLICIT -Wno-UNDRIVEN -Wno-UNSIGNED -Wno-UNUSED -Wno-VARHIDDEN
|
||||
-Wno-WIDTH".
|
||||
|
||||
It is strongly recommended you cleanup your code rather then using this
|
||||
It is strongly recommended you cleanup your code rather than using this
|
||||
option, it is only intended to be use when running test-cases of code
|
||||
received from third parties.
|
||||
|
||||
|
|
@ -994,7 +994,7 @@ To support this, none of the files that Verilator produces will reference
|
|||
any configure generated build-system specific files, such as config.h
|
||||
(which is renamed in Verilator to config_build.h to reduce confusion.) The
|
||||
disadvantage of this approach is that include/verilatedos.h must
|
||||
self-detect the requirements of the target system, rather then using
|
||||
self-detect the requirements of the target system, rather than using
|
||||
configure.
|
||||
|
||||
The target system may also require edits to the Makefiles, the simple
|
||||
|
|
@ -1109,7 +1109,7 @@ call C++ functions from your Verilog code.
|
|||
String arguments will be put directly into the output C++ code. Expression
|
||||
arguments will have the code to evaluate the expression inserted. Thus to
|
||||
call a C++ function, $c("func(",a,")") will result in 'func(a)' in the
|
||||
output C++ code. For input arguments, rather then hard-coding variable
|
||||
output C++ code. For input arguments, rather than hard-coding variable
|
||||
names in the string $c("func(a)"), instead pass the variable as an
|
||||
expression $c("func(",a,")"). This will allow the call to work inside
|
||||
Verilog functions where the variable is flattened out, and also enable
|
||||
|
|
@ -1476,7 +1476,7 @@ When initializing an array, you need to use non-delayed assignments. This
|
|||
is done in the interest of speed; if delayed assignments were used, the
|
||||
simulator would have to copy large arrays every cycle. (In smaller loops,
|
||||
loop unrolling allows the delayed assignment to work, though it's a bit
|
||||
slower then a non-delayed assignment.) Here's an example
|
||||
slower than a non-delayed assignment.) Here's an example
|
||||
|
||||
always @ (posedge clk)
|
||||
if (~reset_l) begin
|
||||
|
|
@ -1563,7 +1563,7 @@ MCDs, which includes the mode parameter to $fopen being mandatory.
|
|||
Verilator will convert the integer used to hold the file descriptor into a
|
||||
internal FILE*. To prevent core dumps due to mis-use, and because integers
|
||||
are 32 bits while FILE*s may be 64 bits, the descriptor must be stored in a
|
||||
reg [63:0] rather then an integer. The define `verilator_file_descriptor in
|
||||
reg [63:0] rather than an integer. The define `verilator_file_descriptor in
|
||||
verilated.v can be used to hide this difference.
|
||||
|
||||
=item $fullskew, $hold, $nochange, $period, $recovery, $recrem, $removal,
|
||||
|
|
@ -1870,7 +1870,7 @@ correctly.
|
|||
Warns that based on width rules of Verilog, two operands have different
|
||||
widths. Verilator generally can intuit the common usages of widths, and
|
||||
you shouldn't need to disable this message like you do with most lint
|
||||
programs. Generally other then simple mistakes, you have two solutions:
|
||||
programs. Generally other than simple mistakes, you have two solutions:
|
||||
|
||||
If it's a constant 0 that's 32 bits or less, simply leave it
|
||||
unwidthed. Verilator considers zero to be any width needed.
|
||||
|
|
@ -1939,13 +1939,13 @@ Visual C++ Version 7 or newer, but this is not tested by the author.
|
|||
|
||||
=item Can you provide binaries?
|
||||
|
||||
At this time I'd prefer to get patches out quickly then have to generate
|
||||
At this time I'd prefer to get patches out quickly than have to generate
|
||||
myriad binaries for many different OS flavors. People have generally
|
||||
requested binaries when they are having problems with their C++
|
||||
compiler. Alas, binaries won't help this, as in the end a fully working C++
|
||||
compiler is required to compile the output of Verilator.
|
||||
|
||||
=item How can it be faster then (name-the-simulator)?
|
||||
=item How can it be faster than (name-the-simulator)?
|
||||
|
||||
Generally, the implied part of the question is "... with all of their
|
||||
manpower they can put into it."
|
||||
|
|
@ -1971,12 +1971,12 @@ does not require you release your Verilog or generated code.
|
|||
|
||||
=item Why is running Verilator so slow?
|
||||
|
||||
Verilator needs more memory then the resulting simulator will require, as
|
||||
Verilator needs more memory than the resulting simulator will require, as
|
||||
Verilator creates internally all of the state of the resulting simulator in
|
||||
order to optimize it. If it takes more then a minute or so (and you're not
|
||||
order to optimize it. If it takes more than a minute or so (and you're not
|
||||
using --debug), see if your machine is paging; most likely you need to run
|
||||
it on a machine with more memory. Verilator is a full 64 bit application
|
||||
and may use more then 4GB, but about 1GB is the maximum typically needed.
|
||||
and may use more than 4GB, but about 1GB is the maximum typically needed.
|
||||
|
||||
=item How do I generate waveforms (traces) in C++?
|
||||
|
||||
|
|
@ -2095,7 +2095,7 @@ bit long longs that fits the width of the signal. Generally, you can use
|
|||
just uint32_t's for 1 to 32 bits, or uint64_t for 1 to 64 bits, and the
|
||||
compiler will properly up-convert smaller entities.
|
||||
|
||||
Signals wider then 64 bits are stored as an array of 32-bit uint32_t's.
|
||||
Signals wider than 64 bits are stored as an array of 32-bit uint32_t's.
|
||||
Thus to read bits 31:0, access signal[0], and for bits 63:32, access
|
||||
signal[1]. Unused bits (for example bit numbers 65-96 of a 65 bit vector)
|
||||
will always be zero. if you change the value you must make sure to pack
|
||||
|
|
@ -2186,8 +2186,8 @@ scratch in C++. This added many optimizations, yielding about a 2-5x
|
|||
performance gain.
|
||||
|
||||
Currently, various language features and performance enhancements are added
|
||||
as the need arises. Verilator is now about 2x faster then in 2002, and is
|
||||
faster then many popular commercial simulators.
|
||||
as the need arises. Verilator is now about 2x faster than in 2002, and is
|
||||
faster than many popular commercial simulators.
|
||||
|
||||
=head1 CONTRIBUTORS
|
||||
|
||||
|
|
|
|||
|
|
@ -1164,7 +1164,7 @@ static inline IData VL_BITSEL_IWII(int, int lbits, int, int, WDataInP lwp, IData
|
|||
int word = VL_BITWORD_I(rd);
|
||||
if ((int)rd>lbits) {
|
||||
return ~0; // Spec says you can go outside the range of a array. Don't coredump if so.
|
||||
// We return all 1's as that's more likely to find bugs (?) then 0's.
|
||||
// We return all 1's as that's more likely to find bugs (?) than 0's.
|
||||
} else {
|
||||
return (lwp[word]>>VL_BITBIT_I(rd));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,8 +46,8 @@
|
|||
# define VL_ATTR_ALIGNED(alignment) ///< Align structure to specified byte alignment
|
||||
# define VL_ATTR_NORETURN ///< Function does not ever return
|
||||
# define VL_ATTR_UNUSED ///< Function that may be never used
|
||||
# define VL_LIKELY(x) (!!(x)) ///< Boolean expression more often true then false
|
||||
# define VL_UNLIKELY(x) (!!(x)) ///< Boolean expression more often false then true
|
||||
# define VL_LIKELY(x) (!!(x)) ///< Boolean expression more often true than false
|
||||
# define VL_UNLIKELY(x) (!!(x)) ///< Boolean expression more often false than true
|
||||
# define VL_PREFETCH_RD(p) ///< Prefetch data with read intent
|
||||
# define VL_PREFETCH_RW(p) ///< Prefetch data with read/write intent
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -459,7 +459,7 @@ void AstNode::relink(AstNRelinker* linkerp) {
|
|||
if (linkerp->m_iterpp) {
|
||||
// If we're iterating over a next() link, we need to follow links off the
|
||||
// NEW node. Thus we pass iteration information via a pointer in the node.
|
||||
// This adds a unfortunate 4 bytes to every AstNode, but is faster then passing
|
||||
// This adds a unfortunate 4 bytes to every AstNode, but is faster than passing
|
||||
// across every function.
|
||||
// If anyone has a cleaner way, I'd be grateful.
|
||||
*(linkerp->m_iterpp) = newp;
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
// BRANCH TRANSFORMATIONS:
|
||||
// At each IF/(IF else).
|
||||
// Count underneath $display/$stop statements.
|
||||
// If more on if then else, this branch is unlikely, or vice-versa.
|
||||
// If more on if than else, this branch is unlikely, or vice-versa.
|
||||
//
|
||||
//*************************************************************************
|
||||
|
||||
|
|
|
|||
|
|
@ -154,7 +154,7 @@ private:
|
|||
nodep->user(1);
|
||||
}
|
||||
virtual void visit(AstConst* nodep, AstNUser*) {
|
||||
// Constants are of unknown size if smaller then 33 bits, becase
|
||||
// Constants are of unknown size if smaller than 33 bits, becase
|
||||
// we're too lazy to wrap every constant in the universe in
|
||||
// ((IData)#).
|
||||
nodep->user(nodep->isQuad() || nodep->isWide());
|
||||
|
|
|
|||
|
|
@ -1023,7 +1023,7 @@ private:
|
|||
// Below lines are magic expressions processed by astgen
|
||||
// "AstNODETYPE { # bracket not paren
|
||||
// $accessor_name, ...
|
||||
// # ,, gets replaced with a , rather then &&
|
||||
// # ,, gets replaced with a , rather than &&
|
||||
// }" # bracket not paren
|
||||
// ,"function to call"
|
||||
// or ,"AstREPLACEMENT_TYPE{ $accessor }"
|
||||
|
|
@ -1204,7 +1204,7 @@ private:
|
|||
TREEOPV("AstRedXor{$lhsp->castExtend()}", "AstRedXor{$lhsp->castExtend()->lhsp()}");
|
||||
TREEOPV("AstOneHot{$lhsp.width1}", "replaceWLhs(nodep)");
|
||||
TREEOPV("AstOneHot0{$lhsp.width1}", "replaceNum(nodep,1)");
|
||||
// Binary AND/OR is faster then logical and/or (usually)
|
||||
// Binary AND/OR is faster than logical and/or (usually)
|
||||
TREEOPV("AstLogAnd{$lhsp.width1, $rhsp.width1}", "AstAnd{$lhsp,$rhsp}");
|
||||
TREEOPV("AstLogOr {$lhsp.width1, $rhsp.width1}", "AstOr{$lhsp,$rhsp}");
|
||||
TREEOPV("AstLogNot{$lhsp.width1}", "AstNot{$lhsp}");
|
||||
|
|
|
|||
|
|
@ -225,7 +225,7 @@ private:
|
|||
|
||||
if (nodep->user5p()) {
|
||||
// Simplistic optimization. If the previous statement in same scope was also a =>,
|
||||
// then we told this nodep->user5 we can use its Vdlyvset rather then making a new one.
|
||||
// then we told this nodep->user5 we can use its Vdlyvset rather than making a new one.
|
||||
// This is good for code like:
|
||||
// for (i=0; i<5; i++) vector[i] <= something;
|
||||
sharedVset = true;
|
||||
|
|
|
|||
|
|
@ -254,7 +254,7 @@ public:
|
|||
virtual void visit(AstReadMem* nodep, AstNUser*) {
|
||||
puts("VL_READMEM_");
|
||||
emitIQW(nodep->filenamep());
|
||||
puts(" ("); // We take a void* rather then emitIQW(nodep->memp());
|
||||
puts(" ("); // We take a void* rather than emitIQW(nodep->memp());
|
||||
puts(nodep->isHex()?"true":"false");
|
||||
putbs(",");
|
||||
puts(cvtToStr(nodep->memp()->widthMin())); // Need real storage width
|
||||
|
|
@ -1214,7 +1214,7 @@ void EmitCImp::emitConfigureImp(AstModule* modp) {
|
|||
void EmitCImp::emitCoverageImp(AstModule* modp) {
|
||||
if (m_coverIds.size()) {
|
||||
puts("\n// Coverage\n");
|
||||
// Rather then putting out SP_COVER_INSERT calls directly, we do it via this function
|
||||
// Rather than putting out SP_COVER_INSERT calls directly, we do it via this function
|
||||
// This gets around gcc slowness constructing all of the template arguments
|
||||
puts("void "+modClassName(m_modp)+"::__vlCoverInsert(SpZeroed<uint32_t>* countp, const char* filename, int lineno, int column,\n");
|
||||
puts( "const char* hier, const char* type, const char* comment) {\n");
|
||||
|
|
|
|||
|
|
@ -111,7 +111,7 @@ void FileLine::warnLintOff(bool flag) {
|
|||
|
||||
FileLine* FileLine::copyOrSameFileLine() {
|
||||
// Return this, or a copy of this
|
||||
// There are often more then one token per line, thus we use the
|
||||
// There are often more than one token per line, thus we use the
|
||||
// same pointer as long as we're on the same line.
|
||||
static FileLine* lastNewp = NULL;
|
||||
if (lastNewp && *lastNewp == *this) {
|
||||
|
|
|
|||
|
|
@ -805,7 +805,7 @@ private:
|
|||
for (int w=0; w<nodep->lhsp()->widthWords(); w++) {
|
||||
AstNode* eqp = newAstWordSelClone (nodep->lhsp(), w);
|
||||
if (w==nodep->lhsp()->widthWords()-1) {
|
||||
// Rather then doing a (slowish) ==##, we OR in the bits that aren't part of the mask
|
||||
// Rather than doing a (slowish) ==##, we OR in the bits that aren't part of the mask
|
||||
eqp = new AstOr (nodep->fileline(),
|
||||
new AstConst (nodep->fileline(), notWideMask(nodep->lhsp())),
|
||||
eqp);
|
||||
|
|
|
|||
|
|
@ -341,7 +341,7 @@ private:
|
|||
if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
|
||||
GateVarVertex* varvertexp = makeVarVertex(varscp);
|
||||
UINFO(5," VARREF to "<<varscp<<endl);
|
||||
// We use weight of one; if we ref the var more then once, when we simplify,
|
||||
// We use weight of one; if we ref the var more than once, when we simplify,
|
||||
// the weight will increase
|
||||
if (nodep->lvalue()) {
|
||||
new V3GraphEdge(&m_graph, m_logicVertexp, varvertexp, 1);
|
||||
|
|
@ -433,7 +433,7 @@ void GateVisitor::optimizeSignals(bool allowMultiIn) {
|
|||
}
|
||||
}
|
||||
else if (!vvertexp->inSize1()) {
|
||||
vvertexp->clearReducible("size!1"); // Can't deal with more then one src
|
||||
vvertexp->clearReducible("size!1"); // Can't deal with more than one src
|
||||
}
|
||||
// Reduce it?
|
||||
if (!vvertexp->reducible()) {
|
||||
|
|
|
|||
|
|
@ -177,10 +177,10 @@ void V3Graph::clear() {
|
|||
void V3Graph::userClearVertices() {
|
||||
// Clear user() in all of tree
|
||||
// We may use the userCnt trick in V3Ast later... For now we don't call this often, and
|
||||
// the extra code on each read of user() would probably slow things down more then help.
|
||||
// the extra code on each read of user() would probably slow things down more than help.
|
||||
for (V3GraphVertex* vertexp = verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
|
||||
vertexp->user(0);
|
||||
vertexp->userp(NULL); // Its a union, but might be different size then user()
|
||||
vertexp->userp(NULL); // Its a union, but might be different size than user()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -189,7 +189,7 @@ void V3Graph::userClearEdges() {
|
|||
for (V3GraphVertex* vertexp = verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
|
||||
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
|
||||
edgep->user(0);
|
||||
edgep->userp(NULL); // Its a union, but might be different size then user()
|
||||
edgep->userp(NULL); // Its a union, but might be different size than user()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -440,7 +440,7 @@ void GraphAcyc::place() {
|
|||
UINFO(4, " Cutable edges = "<<numEdges<<endl);
|
||||
|
||||
vector<V3GraphEdge*> edges; // List of all edges to be processed
|
||||
edges.reserve(numEdges+1); // Make the vector properly sized right off the bat -- faster then reallocating
|
||||
edges.reserve(numEdges+1); // Make the vector properly sized right off the bat -- faster than reallocating
|
||||
for (V3GraphVertex* vertexp = m_breakGraph.verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
|
||||
vertexp->user(0); // Clear in prep of next step
|
||||
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ void V3Graph::deleteCutableOnlyEdges() {
|
|||
}
|
||||
|
||||
// Pass 2, delete those marked
|
||||
// Rather then doing a delete() we set the weight to 0 which disconnects the edge.
|
||||
// Rather than doing a delete() we set the weight to 0 which disconnects the edge.
|
||||
for (V3GraphVertex* vertexp = verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
|
||||
if (vertexp->user()) {
|
||||
//UINFO(7,"Disconnect "<<vertexp->name()<<endl);
|
||||
|
|
@ -99,9 +99,9 @@ private:
|
|||
} else { // Duplicate
|
||||
bool saveOld = true;
|
||||
if (prevEdgep->cutable() && !edgep->cutable()) {
|
||||
saveOld = false; // new !cutable more important then old
|
||||
saveOld = false; // new !cutable more important than old
|
||||
} else if (!prevEdgep->cutable() && edgep->cutable()) {
|
||||
saveOld = true; // old !cutable more important then new
|
||||
saveOld = true; // old !cutable more important than new
|
||||
} else {
|
||||
saveOld = true;
|
||||
if (!m_sumWeights && (prevEdgep->weight() < edgep->weight())) { // Keep max weight
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ public:
|
|||
|
||||
class DfaVertex : public V3GraphVertex {
|
||||
// Each DFA state is captured in this vertex.
|
||||
// Start and accepting are members, rather then the more intuitive
|
||||
// Start and accepting are members, rather than the more intuitive
|
||||
// subclasses, as subclassing them would make it harder to inherit from here.
|
||||
bool m_start; // Start state
|
||||
bool m_accepting; // Accepting state?
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ public:
|
|||
AstVar* varp = it->first->varp();
|
||||
LifeVarEntry* entp = &(it->second);
|
||||
if (!varp->isSigPublic()) {
|
||||
// Rather then track what sigs AstUCFunc/AstUCStmt may change,
|
||||
// Rather than track what sigs AstUCFunc/AstUCStmt may change,
|
||||
// we just don't optimize any public sigs
|
||||
// Check the var entry, and remove if appropriate
|
||||
if (AstNode* oldassp = entp->assignp()) {
|
||||
|
|
|
|||
|
|
@ -174,8 +174,8 @@ private:
|
|||
ports.insert(pinp->name(), pinp);
|
||||
}
|
||||
}
|
||||
// We search ports, rather then in/out declarations as they aren't resolved yet,
|
||||
// and it's easier to do it now then in V3Link when we'd need to repeat steps.
|
||||
// We search ports, rather than in/out declarations as they aren't resolved yet,
|
||||
// and it's easier to do it now than in V3Link when we'd need to repeat steps.
|
||||
for (AstNode* portnodep = nodep->modp()->stmtsp(); portnodep; portnodep=portnodep->nextp()) {
|
||||
if (AstPort* portp = portnodep->castPort()) {
|
||||
if (!ports.findIdName(portp->name())) {
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ private:
|
|||
UINFO(5," "<<nodep<<endl);
|
||||
checkExpected(nodep);
|
||||
// Due to a need to get the arguments, the ParseRefs are under here,
|
||||
// rather then the NodeFTaskRef under the ParseRef.
|
||||
// rather than the NodeFTaskRef under the ParseRef.
|
||||
if (nodep->namep()) {
|
||||
m_exp = AstParseRefExp::FUNC;
|
||||
nodep->namep()->accept(*this); // No next, we don't want to do the edit
|
||||
|
|
|
|||
|
|
@ -721,7 +721,7 @@ V3Number& V3Number::opRepl (const V3Number& lhs, const V3Number& rhs) { // rhs i
|
|||
V3Number& V3Number::opRepl (const V3Number& lhs, uint32_t rhsval) { // rhs is # of times to replicate
|
||||
// i op repl, L(i)*value(rhs) bit return
|
||||
setZero();
|
||||
if (rhsval>8192) m_fileline->v3fatal("More then a 8k bit replication is probably wrong: "<<rhsval);
|
||||
if (rhsval>8192) m_fileline->v3fatal("More than a 8k bit replication is probably wrong: "<<rhsval);
|
||||
int obit = 0;
|
||||
for (unsigned times=0; times<rhsval; times++) {
|
||||
for(int bit=0; bit<lhs.width(); bit++) {
|
||||
|
|
|
|||
|
|
@ -628,7 +628,7 @@ V3Options::V3Options() {
|
|||
addLibExt(""); // So include "filename.v" will find the same file
|
||||
addLibExt(".v");
|
||||
// Default -I
|
||||
addIncDir("."); // Looks better then {long_cwd_path}/...
|
||||
addIncDir("."); // Looks better than {long_cwd_path}/...
|
||||
}
|
||||
|
||||
V3Options::~V3Options() {
|
||||
|
|
|
|||
|
|
@ -337,7 +337,7 @@ private:
|
|||
SplitLogicVertex* vvertexp = (SplitLogicVertex*)nextp->user3p();
|
||||
vvertexp->splitColor(vvertexp->color());
|
||||
uint32_t color = vvertexp->splitColor();
|
||||
if (color >= numVertexes) nextp->v3fatalSrc("More colors then vertexes!\n");
|
||||
if (color >= numVertexes) nextp->v3fatalSrc("More colors than vertexes!\n");
|
||||
if (!color) nextp->v3fatalSrc("No node color assigned\n");
|
||||
if (lastOfColor[color]) {
|
||||
new SplitStrictEdge(&m_graph, lastOfColor[color], vvertexp);
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ private:
|
|||
|
||||
virtual void visit(AstAlways* nodep, AstNUser*) {
|
||||
// Are there any lvalue references below this?
|
||||
// There could be more then one. So, we process the first one found first.
|
||||
// There could be more than one. So, we process the first one found first.
|
||||
AstVarScope* lastSplitVscp = NULL;
|
||||
while (!nodep->user()) {
|
||||
// Find any splittable variables
|
||||
|
|
|
|||
|
|
@ -120,14 +120,14 @@ public:
|
|||
if (!nodep->user3p()) {
|
||||
// Save time - kept a list of allocated but unused V3Numbers
|
||||
// It would be more efficient to do this by size, but the extra accounting
|
||||
// slows things down more then we gain.
|
||||
// slows things down more than we gain.
|
||||
V3Number* nump;
|
||||
if (!m_numFreeps.empty()) {
|
||||
//UINFO(7,"Num Reuse "<<nodep->width()<<endl);
|
||||
nump = m_numFreeps.back(); m_numFreeps.pop_back();
|
||||
nump->width(nodep->width());
|
||||
nump->fileline(nodep->fileline());
|
||||
nump->setLong(value); // We do support more then 32 bit numbers, just valuep=0 in that case
|
||||
nump->setLong(value); // We do support more than 32 bit numbers, just valuep=0 in that case
|
||||
} else {
|
||||
//UINFO(7,"Num New "<<nodep->width()<<endl);
|
||||
nump = new V3Number (nodep->fileline(), nodep->width(), value);
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
// For each CFUNC in graph
|
||||
// Add ASSIGN(SEL(__Vm_funcActivity,activityNumber++),1)
|
||||
// Create __Vm_funcActivity vector
|
||||
// Sort TRACEs by activityNumber(s) they come from (may be more then one)
|
||||
// Sort TRACEs by activityNumber(s) they come from (may be more than one)
|
||||
// Each set of activityNumbers
|
||||
// Add IF (SEL(__Vm_funcActivity,activityNumber),1)
|
||||
// Add traces under that activity number.
|
||||
|
|
|
|||
|
|
@ -171,7 +171,7 @@ private:
|
|||
if (((valStop - valInit)/valInc) > v3Global.opt.unrollCount())
|
||||
return cantUnroll(nodep, "too many iterations");
|
||||
|
||||
// Less then 10 statements in the body?
|
||||
// Less than 10 statements in the body?
|
||||
int bodySize = 0;
|
||||
for (AstNode* bodp = precondsp; bodp; bodp=bodp->nextp()) {
|
||||
bodySize++;
|
||||
|
|
|
|||
|
|
@ -367,7 +367,7 @@ private:
|
|||
}
|
||||
if (vup->c()->final()) {
|
||||
nodep->width(vup->c()->width(),vup->c()->widthMin()); // We don't care
|
||||
if (nodep->width()>64) nodep->v3error("Unsupported: $c can't generate wider then 64 bits");
|
||||
if (nodep->width()>64) nodep->v3error("Unsupported: $c can't generate wider than 64 bits");
|
||||
}
|
||||
// Just let all arguments seek their natural sizes
|
||||
nodep->iterateChildren(*this,WidthVP(ANYSIZE,0,BOTH).p());
|
||||
|
|
@ -535,7 +535,7 @@ private:
|
|||
nodep->rhsp()->iterateAndNext(*this,WidthVP(awidth,awidth,FINAL).p());
|
||||
nodep->width(awidth,awidth); // We know the assign will truncate, so rather
|
||||
//UINFO(0,"aw "<<awidth<<" w"<<nodep->rhsp()->width()<<" m"<<nodep->rhsp()->widthMin()<<endl);
|
||||
// then using "width" and have the optimizer truncate the result, we do
|
||||
// than using "width" and have the optimizer truncate the result, we do
|
||||
// it using the normal width reduction checks.
|
||||
widthCheck(nodep,"Assign RHS",nodep->rhsp(),awidth,awidth);
|
||||
//if (debug()) nodep->dumpTree(cout," AssignPos: ");
|
||||
|
|
|
|||
|
|
@ -1375,7 +1375,7 @@ AstNode* V3Parse::createSupplyExpr(FileLine* fileline, string name, int value) {
|
|||
FileLine* newfl = new FileLine (fileline);
|
||||
newfl->warnOff(V3ErrorCode::WIDTH, true);
|
||||
AstNode* nodep = new AstConst(newfl, V3Number(fileline));
|
||||
// Adding a NOT is less work then figuring out how wide to make it
|
||||
// Adding a NOT is less work than figuring out how wide to make it
|
||||
if (value) nodep = new AstNot(newfl, nodep);
|
||||
nodep = new AstAssignW(newfl, new AstVarRef(fileline, name, true),
|
||||
nodep);
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ module t_arith(/*AUTOARG*/
|
|||
if (( 1'b0 ? 3'h3 : 1'b0 ? 3'h2 : 1'b1 ? 3'h1 : 3'h0) !== 3'h1) $stop;
|
||||
// verilator lint_off WIDTH
|
||||
// surefire lint_off CNDWID
|
||||
if (( 8'h10 + 1'b0 ? 8'he : 8'hf) !== 8'he) $stop; // + is higher then ?
|
||||
if (( 8'h10 + 1'b0 ? 8'he : 8'hf) !== 8'he) $stop; // + is higher than ?
|
||||
// surefire lint_on CNDWID
|
||||
// verilator lint_on WIDTH
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue