Mario1159/verilator
1
0
Fork 0
forked from github/verilator
Code Pull Requests Releases 1 Activity

Commentary: Fix spelling in C++ comments (#3797) (#3798)

Browse Source
This commit is contained in:
Larry Doolittle 2022-12-02 15:46:38 -08:00 committed by GitHub
parent 701d2277cd
commit f27cf4c804
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
49 changed files with 97 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/verilated.cpp
View File

@ -281,7 +281,7 @@ void VL_PRINTF_MT(const char* formatp, ...) VL_MT_SAFE {
static uint32_t vl_sys_rand32() VL_MT_SAFE {
// Return random 32-bits using system library.
// Used only to construct seed for Verilator's PNRG.
// Used only to construct seed for Verilator's PRNG.
static VerilatedMutex s_mutex;
const VerilatedLockGuard lock{s_mutex}; // Otherwise rand is unsafe
#if defined(_WIN32) && !defined(__CYGWIN__)
@ -2223,7 +2223,7 @@ static const char* vl_time_str(int scale) VL_PURE {
return names[2 - scale];
}
double vl_time_multiplier(int scale) VL_PURE {
// Return timescale multipler -18 to +18
// Return timescale multiplier -18 to +18
// For speed, this does not check for illegal values
// cppcheck-has-bug-suppress arrayIndexOutOfBoundsCond
if (scale < 0) {
@ -2340,8 +2340,8 @@ void VerilatedContext::checkMagic(const VerilatedContext* contextp) {
VerilatedContext::Serialized::Serialized() {
constexpr int8_t picosecond = -12;
m_timeunit = picosecond; // Initial value until overriden by _Vconfigure
m_timeprecision = picosecond; // Initial value until overriden by _Vconfigure
m_timeunit = picosecond; // Initial value until overridden by _Vconfigure
m_timeprecision = picosecond; // Initial value until overridden by _Vconfigure
}
void VerilatedContext::assertOn(bool flag) VL_MT_SAFE {
@ -2659,7 +2659,7 @@ void VerilatedContext::randSeed(int val) VL_MT_SAFE {
const VerilatedLockGuard lock{VerilatedContextImp::s().s_randMutex};
m_s.m_randSeed = val;
const uint64_t newEpoch = VerilatedContextImp::s().s_randSeedEpoch + 1;
// Obververs must see new epoch AFTER seed updated
// Observers must see new epoch AFTER seed updated
std::atomic_signal_fence(std::memory_order_release);
VerilatedContextImp::s().s_randSeedEpoch = newEpoch;
}
@ -3117,7 +3117,7 @@ void VlDeleter::deleteAll() {
if (m_newGarbage.empty()) break;
VerilatedLockGuard deleteLock{m_deleteMutex};
std::swap(m_newGarbage, m_toDelete);
lock.unlock(); // So destuctors can enqueue new objects
lock.unlock(); // So destructors can enqueue new objects
for (VlDeletable* const objp : m_toDelete) delete objp;
m_toDelete.clear();
}

2
include/verilated.h
View File

@ -440,7 +440,7 @@ public:
void errorLimit(int val) VL_MT_SAFE;
/// Return number of errors/assertions before stop
int errorLimit() const VL_MT_SAFE { return m_s.m_errorLimit; }
/// Set to throw fatal error on $stop/non-fatal ettot
/// Set to throw fatal error on $stop/non-fatal error
void fatalOnError(bool flag) VL_MT_SAFE;
/// Return if to throw fatal error on $stop/non-fatal
bool fatalOnError() const VL_MT_SAFE { return m_s.m_fatalOnError; }

2
include/verilated_funcs.h
View File

@ -1394,7 +1394,7 @@ static inline IData VL_STREAML_FAST_III(int lbits, IData ld, IData rd_log2) VL_P
//
// If lbits is not a multiple of the slice size (i.e., lbits % rd != 0),
// then we end up with a "gap" in our reversed result. For example, if we
// have a 5-bit Verlilog signal (lbits=5) in an 8-bit C data type:
// have a 5-bit Verilog signal (lbits=5) in an 8-bit C data type:
//
// ld = ---43210
//

2
include/verilated_profiler.cpp
View File

@ -119,7 +119,7 @@ VerilatedVirtualBase* VlExecutionProfiler::construct(VerilatedContext& context)
},
&data);
// Wait until initializationis complete
// Wait until initialization is complete
threadPoolp->workerp(i)->wait();
}
}

2
include/verilated_timing.h
View File

@ -194,7 +194,7 @@ public:
//=============================================================================
// VlTriggerScheduler stores coroutines to be resumed by a trigger. It does not keep track of its
// trigger, relying on calling code to resume when appropriate. Coroutines are kept in two stages
// - 'uncommitted' and 'ready'. Whenever a coroutine is suspended, it lands in the 'uncommited'
// - 'uncommitted' and 'ready'. Whenever a coroutine is suspended, it lands in the 'uncommitted'
// stage. Only when commit() is called, these coroutines get moved to the 'ready' stage. That's
// when they can be resumed. This is done to avoid resuming processes before they start waiting.

6
include/verilated_trace_imp.h
View File

@ -82,7 +82,7 @@ static std::string doubleToTimescale(double value) {
template <>
uint32_t* VerilatedTrace<VL_SUB_T, VL_BUF_T>::getOffloadBuffer() {
uint32_t* bufferp;
// Some jitter is expected, so some number of alternative offlaod buffers are
// Some jitter is expected, so some number of alternative offload buffers are
// required, but don't allocate more than 8 buffers.
if (m_numOffloadBuffers < 8) {
// Allocate a new buffer if none is available
@ -348,7 +348,7 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::traceInit() VL_MT_UNSAFE {
// Else if was empty, m_sigs_enabledp = nullptr to short circuit tests
// But it isn't, so alloc one bit for each code to indicate enablement
// We don't want to still use m_signs_enabledVec as std::vector<bool> is not
// guarenteed to be fast
// guaranteed to be fast
m_sigs_enabledp = new uint32_t[1 + VL_WORDS_I(nextCode())]{0};
m_sigs_enabledVec.reserve(nextCode());
for (size_t code = 0; code < nextCode(); ++code) {
@ -513,7 +513,7 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::runCallbacks(const std::vector<Callback
mainThreadWorkerData.push_back(itemp);
}
}
// Execute main thead jobs
// Execute main thread jobs
for (ParallelWorkerData* const itemp : mainThreadWorkerData) {
parallelWorkerTask(itemp, false);
}

4
include/verilated_types.h
View File

@ -412,7 +412,7 @@ public:
void sort(Func with_func) {
// with_func returns arbitrary type to use for the sort comparison
std::sort(m_deque.begin(), m_deque.end(), [=](const T_Value& a, const T_Value& b) {
// index number is meaninless with sort, as it changes
// index number is meaningless with sort, as it changes
return with_func(0, a) < with_func(0, b);
});
}
@ -421,7 +421,7 @@ public:
void rsort(Func with_func) {
// with_func returns arbitrary type to use for the sort comparison
std::sort(m_deque.rbegin(), m_deque.rend(), [=](const T_Value& a, const T_Value& b) {
// index number is meaninless with sort, as it changes
// index number is meaningless with sort, as it changes
return with_func(0, a) < with_func(0, b);
});
}

8
include/verilated_vcd_c.cpp
View File

@ -475,7 +475,7 @@ void VerilatedVcd::declare(uint32_t code, const char* name, const char* wirep, b
m_suffixes.resize(nextCode() * VL_TRACE_SUFFIX_ENTRY_SIZE * 2, 0);
}
// Keep upper bound on bytes a single signal cna emit into the buffer
// Keep upper bound on bytes a single signal can emit into the buffer
m_maxSignalBytes = std::max<size_t>(m_maxSignalBytes, bits + 32);
// Make sure write buffer is large enough, plus header
bufferResize(m_maxSignalBytes + 1024);
@ -571,7 +571,7 @@ void VerilatedVcd::declDouble(uint32_t code, const char* name, bool array, int a
VerilatedVcd::Buffer* VerilatedVcd::getTraceBuffer() {
VerilatedVcd::Buffer* const bufp = new Buffer{*this};
if (parallel()) {
// Note: This is called from VeriltedVcd::dump, which already holds the lock
// Note: This is called from VerilatedVcd::dump, which already holds the lock
// If no buffer available, allocate a new one
if (m_freeBuffers.empty()) {
constexpr size_t pageSize = 4096;
@ -594,7 +594,7 @@ VerilatedVcd::Buffer* VerilatedVcd::getTraceBuffer() {
void VerilatedVcd::commitTraceBuffer(VerilatedVcd::Buffer* bufp) {
if (parallel()) {
// Note: This is called from VeriltedVcd::dump, which already holds the lock
// Note: This is called from VerilatedVcd::dump, which already holds the lock
// Resize output buffer. Note, we use the full size of the trace buffer, as
// this is a lot more stable than the actual occupancy of the trace buffer.
// This helps us to avoid re-allocations due to small size changes.
@ -695,7 +695,7 @@ void VerilatedVcdBuffer::finishLine(uint32_t code, char* writep) {
VL_ATTR_ALWINLINE
void VerilatedVcdBuffer::emitEvent(uint32_t code, VlEvent newval) {
const bool triggered = newval.isTriggered();
// TODO : It seems that untriggerd events are not filtered
// TODO : It seems that untriggered events are not filtered
// should be tested before this last step
if (triggered) {
// Don't prefetch suffix as it's a bit too late;

2
include/verilated_vcd_c.h
View File

@ -168,7 +168,7 @@ void VerilatedVcd::Super::dumpvars(int level, const std::string& hier);
// VerilatedVcdBuffer
class VerilatedVcdBuffer VL_NOT_FINAL {
// Give the trace file ans sub-classes access to the private bits
// Give the trace file and sub-classes access to the private bits
friend VerilatedVcd;
friend VerilatedVcd::Super;
friend VerilatedVcd::Buffer;

10
include/verilated_vpi.cpp
View File

@ -1792,11 +1792,11 @@ void vl_get_value(const VerilatedVar* varp, void* varDatap, p_vpi_value valuep,
// align so least significant 3 bits represent octal char
val >>= idx.rem;
if (i == (chars - 1)) {
// most signifcant char, mask off non existant bits when vector
// most significant char, mask off nonexistent bits when vector
// size is not a multiple of 3
const unsigned int rem = varp->packed().elements() % 3;
if (rem) {
// generate bit mask & zero non existant bits
// generate bit mask & zero nonexistent bits
val &= (1 << rem) - 1;
}
}
@ -1842,11 +1842,11 @@ void vl_get_value(const VerilatedVar* varp, void* varDatap, p_vpi_value valuep,
for (i = 0; i < chars; ++i) {
char val = (datap[i >> 1] >> ((i & 1) << 2)) & 15;
if (i == (chars - 1)) {
// most signifcant char, mask off non existant bits when vector
// most significant char, mask off nonexistent bits when vector
// size is not a multiple of 4
const unsigned int rem = varp->packed().elements() & 3;
if (rem) {
// generate bit mask & zero non existant bits
// generate bit mask & zero nonexistent bits
val &= (1 << rem) - 1;
}
}
@ -2269,7 +2269,7 @@ PLI_INT32 vpi_chk_error(p_vpi_error_info error_info_p) {
VerilatedVpiImp::assertOneCheck();
p_vpi_error_info const _error_info_p = VerilatedVpiImp::error_info()->getError();
if (error_info_p && _error_info_p) *error_info_p = *_error_info_p;
if (!_error_info_p) return 0; // no error occured
if (!_error_info_p) return 0; // no error occurred
return _error_info_p->level; // return error severity level
}

2
include/verilated_vpi.h
View File

@ -36,7 +36,7 @@
//======================================================================
/// Class for namespace-like groupng of Verilator VPI functions.
/// Class for namespace-like grouping of Verilator VPI functions.
class VerilatedVpi final {
public:

8
include/verilatedos.h
View File

@ -111,12 +111,12 @@
# define VL_ATTR_WEAK ///< Attribute that function external that is optionally defined
#endif
#ifndef VL_CAPABILITY
# define VL_ACQUIRE(...) ///< Function aquires a capability/lock (-fthread-safety)
# define VL_ACQUIRE_SHARED(...) ///< Function aquires a shared capability/lock (-fthread-safety)
# define VL_ACQUIRE(...) ///< Function acquires a capability/lock (-fthread-safety)
# define VL_ACQUIRE_SHARED(...) ///< Function acquires a shared capability/lock (-fthread-safety)
# define VL_RELEASE(...) ///< Function releases a capability/lock (-fthread-safety)
# define VL_RELEASE_SHARED(...) ///< Function releases a shared capability/lock (-fthread-safety)
# define VL_TRY_ACQUIRE(...) ///< Function returns bool if aquired a capability (-fthread-safety)
# define VL_TRY_ACQUIRE_SHARED(...) ///< Function returns bool if aquired shared (-fthread-safety)
# define VL_TRY_ACQUIRE(...) ///< Function returns bool if acquired a capability (-fthread-safety)
# define VL_TRY_ACQUIRE_SHARED(...) ///< Function returns bool if acquired shared (-fthread-safety)
# define VL_REQUIRES(x) ///< Function requires a capability inbound (-fthread-safety)
# define VL_EXCLUDES(x) ///< Function requires not having a capability inbound (-fthread-safety)
# define VL_CAPABILITY(x) ///< Name of capability/lock (-fthread-safety)

2
src/V3Active.cpp
View File

@ -88,7 +88,7 @@ protected:
// Recursively traverse the graph to determine whether every control 'BLOCK' has an assignment
// to the output we are currently analysing (the output whose 'user() is set), if so return
// true. Where a BLOCK contains a BRANCH, both the if and else sides of the branch must return
// true for the BRANCH to evalute to true. A BLOCK however needs only a single one of its
// true for the BRANCH to evaluate to true. A BLOCK however needs only a single one of its
// siblings to evaluate true in order to evaluate true itself. On output vertex only evaluates
// true if it is the vertex we are analyzing on this check

2
src/V3AssertPre.cpp
View File

@ -91,7 +91,7 @@ private:
if (AstFuncRef* const funcrefp = VN_CAST(nodep->propp(), FuncRef)) {
if (AstProperty* const propp = VN_CAST(funcrefp->taskp(), Property)) {
AstPropSpec* propExprp = getPropertyExprp(propp);
// Substitute inner property call befory copying in order to not doing the same for
// Substitute inner property call before copying in order to not doing the same for
// each call of outer property call.
propExprp = substitutePropertyCall(propExprp);
// Clone subtree after substitution. It is needed, because property might be called

2
src/V3Ast.cpp
View File

@ -112,7 +112,7 @@ string AstNode::encodeName(const string& namein) {
}
// Shorten names
// TODO long term use VName in place of "string name"
// Then we also won't need to save the table of hased values
// Then we also won't need to save the table of hashed values
VName vname{out};
return vname.hashedName();
}

6
src/V3AstNodeExpr.h
View File

@ -115,7 +115,7 @@ public:
class AstNodeSel VL_NOT_FINAL : public AstNodeBiop {
// Single bit range extraction, perhaps with non-constant selection or array selection
// @astgen alias op1 := fromp // Expression we are indexing into
// @astgen alias op2 := bitp // The index // TOOD: rename to idxp
// @astgen alias op2 := bitp // The index // TODO: rename to idxp
protected:
AstNodeSel(VNType t, FileLine* fl, AstNodeExpr* fromp, AstNodeExpr* bitp)
: AstNodeBiop{t, fl, fromp, bitp} {}
@ -4178,7 +4178,7 @@ public:
// === AstNodeCond ===
class AstCond final : public AstNodeCond {
// Conditional ?: expressoin
// Conditional ?: expression
public:
AstCond(FileLine* fl, AstNodeExpr* condp, AstNodeExpr* thenp, AstNodeExpr* elsep)
: ASTGEN_SUPER_Cond(fl, condp, thenp, elsep) {}
@ -4463,7 +4463,7 @@ public:
int instrCount() const override { return INSTR_COUNT_DBL; }
};
class AstIsUnbounded final : public AstNodeUniop {
// True if is unmbounded ($)
// True if is unbounded ($)
public:
AstIsUnbounded(FileLine* fl, AstNodeExpr* lhsp)
: ASTGEN_SUPER_IsUnbounded(fl, lhsp) {

16
src/V3AstNodeOther.h
View File

@ -15,7 +15,7 @@
//*************************************************************************
//
// This files contains all 'AstNode' sub-types that relate to other constructs
// not covered by the more speficic V3AstNode*.h files.
// not covered by the more specific V3AstNode*.h files.
//
//*************************************************************************
@ -83,7 +83,7 @@ private:
bool m_isHideProtected : 1; // Verilog protected
bool m_pure : 1; // DPI import pure (vs. virtual pure)
bool m_pureVirtual : 1; // Pure virtual
bool m_recursive : 1; // Recusive or part of recursion
bool m_recursive : 1; // Recursive or part of recursion
bool m_underGenerate : 1; // Under generate (for warning)
bool m_virtual : 1; // Virtual method in class
VLifetime m_lifetime; // Lifetime
@ -175,7 +175,7 @@ public:
bool isFirstInMyListOfStatements(AstNode* n) const override { return n == stmtsp(); }
};
class AstNodeFile VL_NOT_FINAL : public AstNode {
// Emitted Otput file
// Emitted Output file
// Parents: NETLIST
// @astgen op1 := tblockp : Optional[AstTextBlock]
private:
@ -210,7 +210,7 @@ private:
bool m_modTrace : 1; // Tracing this module
bool m_inLibrary : 1; // From a library, no error if not used, never top level
bool m_dead : 1; // LinkDot believes is dead; will remove in Dead visitors
bool m_hierBlock : 1; // Hiearchical Block marked by HIER_BLOCK pragma
bool m_hierBlock : 1; // Hierarchical Block marked by HIER_BLOCK pragma
bool m_internal : 1; // Internally created
bool m_recursive : 1; // Recursive module
bool m_recursiveClone : 1; // If recursive, what module it clones, otherwise nullptr
@ -356,7 +356,7 @@ class AstNodeCoverOrAssert VL_NOT_FINAL : public AstNodeStmt {
// @astgen op1 := propp : AstNode
// @astgen op2 := sentreep : Optional[AstSenTree]
// op3 used by some sub-types only
// @astgen op4 := passsp: List[AstNode] // Statments when propp is passing/truthly
// @astgen op4 := passsp: List[AstNode] // Statements when propp is passing/truthly
string m_name; // Name to report
const bool m_immediate; // Immediate assertion/cover
public:
@ -1183,7 +1183,7 @@ public:
void packagep(AstPackage* nodep) { m_packagep = nodep; }
};
class AstPin final : public AstNode {
// A port or parameter assignment on an instantiaton
// A port or parameter assignment on an instantiation
// @astgen op1 := exprp : Optional[AstNode] // NodeExpr or NodeDType (nullptr if unconnected)
private:
int m_pinNum; // Pin number
@ -3353,7 +3353,7 @@ public:
// === AstNodeCoverOrAssert ===
class AstAssert final : public AstNodeCoverOrAssert {
// @astgen op3 := failsp: List[AstNode] // Statments when propp is failing/falsey
// @astgen op3 := failsp: List[AstNode] // Statements when propp is failing/falsey
public:
ASTGEN_MEMBERS_AstAssert;
AstAssert(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp, bool immediate,
@ -3364,7 +3364,7 @@ public:
};
class AstAssertIntrinsic final : public AstNodeCoverOrAssert {
// A $cast or other compiler inserted assert, that must run even without --assert option
// @astgen op3 := failsp: List[AstNode] // Statments when propp is failing/falsey
// @astgen op3 := failsp: List[AstNode] // Statements when propp is failing/falsey
public:
ASTGEN_MEMBERS_AstAssertIntrinsic;
AstAssertIntrinsic(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp,

4
src/V3Class.cpp
View File

@ -114,7 +114,7 @@ private:
iterateChildren(nodep);
if (m_packageScopep) {
if (m_ftaskp && m_ftaskp->lifetime().isStatic()) {
// Move later, or we wouldn't keep interating the class
// Move later, or we wouldn't keep iterating the class
// We're really moving the VarScope but we might not
// have a pointer to it yet
m_toScopeMoves.emplace_back(std::make_pair(nodep, m_packageScopep));
@ -145,7 +145,7 @@ private:
}
void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
// Don't move now, or wouldn't keep interating the class
// Don't move now, or wouldn't keep iterating the class
// TODO move function statics only
// if (m_classScopep) {
// m_toScopeMoves.push_back(std::make_pair(nodep, m_classScopep));

4
src/V3Config.cpp
View File

@ -258,7 +258,7 @@ class V3ConfigFile final {
using WaiverSetting = std::pair<V3ErrorCode, std::string>; // Waive code if string matches
using Waivers = std::vector<WaiverSetting>; // List of {code,wildcard string}
LineAttrMap m_lineAttrs; // Atributes to line mapping
LineAttrMap m_lineAttrs; // Attributes to line mapping
IgnLines m_ignLines; // Ignore line settings
Waivers m_waivers; // Waive messages
@ -416,7 +416,7 @@ public:
for (const auto& ent : m_entries) {
// We apply shortest match first for each rule component
// (Otherwise the levels would be useless as "--scope top* --levels 1" would
// always match at every scopepart, and we wound't know how to count levels)
// always match at every scopepart, and we wouldn't know how to count levels)
int partLevel = 1;
for (string::size_type partEnd = 0; true;) {
partEnd = scope.find('.', partEnd + 1);

4
src/V3Const.cpp
View File

@ -835,7 +835,7 @@ public:
// Set width of masks to expected result width. This is required to prevent later removal
// of the masking node e.g. by the "AND with all ones" rule. If the result width happens
// to be 1, we still need to ensure the AstAnd is not dropped, so use a wider maks in this
// to be 1, we still need to ensure the AstAnd is not dropped, so use a wider mask in this
// special case.
const int maskWidth = resultWidth == 1 ? VL_IDATASIZE : resultWidth;
@ -1051,7 +1051,7 @@ private:
// Push down a AND into conditional, when one side of conditional is constant
// (otherwise we'd be trading one operation for two operations)
// V3Clean often makes this pattern, as it postpones the AND until
// as high as possible, which is usally the right choice, except for this.
// as high as possible, which is usually the right choice, except for this.
AstNodeCond* const condp = VN_CAST(nodep->rhsp(), NodeCond);
if (!condp) return false;
if (!VN_IS(condp->thenp(), Const) && !VN_IS(condp->elsep(), Const)) return false;

2
src/V3DfgDecomposition.cpp
View File

@ -306,7 +306,7 @@ class ExtractCyclicComponents final {
void mergeSCCs() {
// Ensure that component boundaries are always at variables, by merging SCCs. Merging stops
// at variable boundaries, so we don't need to iterate variables. Constants are reachable
// from their sinks, or ar unused, so we don't need to iterate them either.
// from their sinks, or are unused, so we don't need to iterate them either.
for (DfgVertex *vtxp = m_dfg.opVerticesBeginp(), *nextp; vtxp; vtxp = nextp) {
nextp = vtxp->verticesNext();
DfgVertex& vtx = *vtxp;

2
src/V3DfgPasses.cpp
View File

@ -226,7 +226,7 @@ void V3DfgPasses::removeUnused(DfgGraph& dfg) {
// Head of work list. Note that we want all next pointers in the list to be non-zero (including
// that of the last element). This allows as to do two important things: detect if an element
// is in the list by checking for a non-zero next poitner, and easy prefetching without
// is in the list by checking for a non-zero next pointer, and easy prefetching without
// conditionals. The address of the graph is a good sentinel as it is a valid memory address,
// and we can easily check for the end of the list.
DfgVertex* const sentinelp = reinterpret_cast<DfgVertex*>(&dfg);

2
src/V3DfgPeephole.cpp
View File

@ -141,7 +141,7 @@ class V3DfgPeephole final : public DfgVisitor {
AstNodeDType* const m_bitDType = DfgVertex::dtypeForWidth(1); // Common, so grab it up front
// Head of work list. Note that we want all next pointers in the list to be non-zero (including
// that of the last element). This allows as to do two important things: detect if an element
// is in the list by checking for a non-zero next poitner, and easy prefetching without
// is in the list by checking for a non-zero next pointer, and easy prefetching without
// conditionals. The 'this' pointer is a good sentinel as it is a valid memory address, and we
// can easily check for the end of the list.
DfgVertex* m_workListp = reinterpret_cast<DfgVertex*>(this);

2
src/V3EmitCImp.cpp
View File

@ -543,7 +543,7 @@ class EmitCImp final : EmitCFunc {
m_modp = modp;
// Emit implementation of this module, if this is an AstClassPackage, then put the
// corresponding AstClass implementation in the same file as often optimziations are
// corresponding AstClass implementation in the same file as often optimizations are
// possible when both are seen by the compiler
// TODO: is the above comment still true?

2
src/V3EmitCMain.cpp
View File

@ -51,7 +51,7 @@ private:
// Not defining main_time/vl_time_stamp, so
v3Global.opt.addCFlags("-DVL_TIME_CONTEXT"); // On MSVC++ anyways
// Heavly commented output, as users are likely to look at or copy this code
// Heavily commented output, as users are likely to look at or copy this code
ofp()->putsHeader();
puts("// DESCRIPTION: main() calling loop, created with Verilator --main\n");
puts("\n");

2
src/V3FileLine.h
View File

@ -81,7 +81,7 @@ class FileLineSingleton final {
msgEnSetIdx_t addMsgEnBitSet(const MsgEnBitSet& bitSet);
// Add index of default bitset
msgEnSetIdx_t defaultMsgEnIndex();
// Set bitIdx to value in bitset at interned idnex setIdx, return interned index of result
// Set bitIdx to value in bitset at interned index setIdx, return interned index of result
msgEnSetIdx_t msgEnSetBit(msgEnSetIdx_t setIdx, size_t bitIdx, bool value);
// Return index to intersection set
msgEnSetIdx_t msgEnAnd(msgEnSetIdx_t lhsIdx, msgEnSetIdx_t rhsIdx);

2
src/V3Gate.cpp
View File

@ -785,7 +785,7 @@ private:
std::unordered_set<AstNode*> m_nodeDeleteds; // Any node in this hash was deleted
bool same(AstNode* node1p, AstNode* node2p) {
// Regarding the complexity of this funcition 'same':
// Regarding the complexity of this function 'same':
// Applying this comparison function to a a set of n trees pairwise is O(n^2) in the
// number of comparisons (number of pairs). AstNode::sameTree itself, is O(sizeOfTree) in
// the worst case, which happens if the operands of sameTree are indeed identical copies,

2
src/V3Global.cpp
View File

@ -1,6 +1,6 @@
// -*- mode: C++; c-file-style: "cc-mode" -*-
//*************************************************************************
// DESCRIPTION: Verilator: Common implemenetations
// DESCRIPTION: Verilator: Common implementations
//
// Code available from: https://verilator.org
//

2
src/V3Global.h
View File

@ -126,7 +126,7 @@ public:
V3Global() {}
void boot();
void clear();
void shutdown(); // Release allocated resorces
void shutdown(); // Release allocated resources
// ACCESSORS (general)
AstNetlist* rootp() const VL_MT_SAFE { return m_rootp; }
VWidthMinUsage widthMinUsage() const { return m_widthMinUsage; }

4
src/V3HierBlock.cpp
View File

@ -118,7 +118,7 @@ V3HierBlock::StrGParams V3HierBlock::stringifyParams(const GParams& gparams, boo
// V3Param.cpp. See also ParamVisitor::checkSupportedParam() in the file.
if (constp->isDouble()) {
// 64 bit width of hex can be expressed with 16 chars.
// 32 chars must be long enough for hexadecial floating point
// 32 chars must be long enough for hexadecimal floating point
// considering prefix of '0x', '.', and 'P'.
std::vector<char> hexFpStr(32, '\0');
const int len = VL_SNPRINTF(hexFpStr.data(), hexFpStr.size(), "%a",
@ -377,7 +377,7 @@ V3HierBlockPlan::HierVector V3HierBlockPlan::hierBlocksSorted() const {
const V3HierBlock* hblockp = sorted[i];
const V3HierBlock::HierBlockSet& p = hblockp->parents();
for (V3HierBlock::HierBlockSet::const_iterator it = p.begin(); it != p.end(); ++it) {
// Delete hblockp from parrents. If a parent does not have a child anymore, then it is
// Delete hblockp from parents. If a parent does not have a child anymore, then it is
// a leaf too.
const auto parentIt = childrenOfHierBlock.find(*it);
UASSERT_OBJ(parentIt != childrenOfHierBlock.end(), (*it)->modp(), "must be included");

4
src/V3HierBlock.h
View File

@ -87,14 +87,14 @@ public:
string hierGenerated(bool withDir) const;
// Returns the original HDL file if it is not included in v3Global.opt.vFiles().
string vFileIfNecessary() const;
// Write command line argumuents to .f file for this hierarchical block
// Write command line arguments to .f file for this hierarchical block
void writeCommandArgsFile(bool forCMake) const;
string commandArgsFileName(bool forCMake) const;
};
//######################################################################
// Holds relashonship between AstNodeModule and V3HierBlock
// Holds relationship between AstNodeModule and V3HierBlock
class V3HierBlockPlan final {
using HierMap = std::unordered_map<const AstNodeModule*, V3HierBlock*>;
HierMap m_blocks;

2
src/V3Inst.cpp
View File

@ -510,7 +510,7 @@ public:
// If a pin connection is "simple" leave it as-is
// Else create a intermediate wire to perform the interconnect
// Return the new assignment, if one was made
// Note this module calles cloneTree() via new AstVar
// Note this module calls cloneTree() via new AstVar
AstVar* const pinVarp = pinp->modVarp();
if (!pinp->exprp()) {
// No-connect, perhaps promote based on `unconnected_drive,

2
src/V3LinkParse.cpp
View File

@ -560,7 +560,7 @@ private:
AstNode* scanp = nodep;
// Skip over the New's statement
for (; scanp && !VN_IS(scanp, StmtExpr); scanp = scanp->backp()) {}
if (VN_IS(scanp, StmtExpr)) { // Ignore warnign if something not understood
if (VN_IS(scanp, StmtExpr)) { // Ignore warning if something not understood
scanp = scanp->backp();
for (; scanp; scanp = scanp->backp()) {
if (VN_IS(scanp, NodeStmt) || VN_IS(scanp, NodeModule)

6
src/V3MergeCond.cpp
View File

@ -177,7 +177,7 @@ class CodeMotionAnalysisVisitor final : public VNVisitor {
std::vector<V3DupFinder> m_stack;
StmtProperties* m_propsp = nullptr; // StmtProperties structure of current AstNodeStmt
// Extract condition expression from a megeable conditional statement, if any
// Extract condition expression from a mergeable conditional statement, if any
static AstNodeExpr* extractCondition(const AstNodeStmt* nodep) {
AstNodeExpr* conditionp = nullptr;
if (const AstNodeAssign* const assignp = VN_CAST(nodep, NodeAssign)) {
@ -590,7 +590,7 @@ private:
}
// Fold the RHS expression of an assignment assuming the given condition state.
// Unlink bits from the RHS which is only used once, and can be reused (is an unomdified
// Unlink bits from the RHS which is only used once, and can be reused (is an unmodified
// sub-tree). What remains of the RHS is expected to be deleted by the caller.
AstNodeExpr* foldAndUnlink(AstNodeExpr* rhsp, bool condTrue) {
if (rhsp->sameTree(m_mgCondp)) {
@ -793,7 +793,7 @@ private:
}
// If this node is the next expected node and is helpful to add to the list, do so,
// otherwise end the current merge. Return ture if added, false if ended merge.
// otherwise end the current merge. Return true if added, false if ended merge.
bool addIfHelpfulElseEndMerge(AstNodeStmt* nodep) {
UASSERT_OBJ(m_mgFirstp, nodep, "List must be open");
if (!checkOrMakeMergeable(nodep)) return false;

10
src/V3OptionParser.h
View File

@ -29,8 +29,8 @@
class VOptionBool;
#endif
// Typycal usage would look as below.
// See also V3Options::parseOptsList() in V3Optoins.cpp for more detailed usage.
// Typical usage would look as below.
// See also V3Options::parseOptsList() in V3Options.cpp for more detailed usage.
//
// V3OptionParser parser;
// V3OptionParser::AppendHelper DECL_OPTION{parser};
@ -89,8 +89,8 @@ class V3OptionParser::ActionIfs VL_NOT_FINAL {
public:
virtual ~ActionIfs() = default;
virtual bool isValueNeeded() const = 0; // Need val of "-opt val"
virtual bool isFOnOffAllowed() const = 0; // true if "-fno-opt" is allowd
virtual bool isOnOffAllowed() const = 0; // true if "-no-opt" is allowd
virtual bool isFOnOffAllowed() const = 0; // true if "-fno-opt" is allowed
virtual bool isOnOffAllowed() const = 0; // true if "-no-opt" is allowed
virtual bool isPartialMatchAllowed() const = 0; // true if "-Wno-" matches "-Wno-fatal"
virtual bool isUndocumented() const = 0; // Will not be suggested in typo
// Set a value or run callback
@ -117,7 +117,7 @@ public:
private:
// MEMBERS
V3OptionParser& m_parser; // The actual option registory
V3OptionParser& m_parser; // The actual option registry
public:
// METHODS

4
src/V3Order.cpp
View File

@ -173,7 +173,7 @@ class OrderBuildVisitor final : public VNVisitor {
// Current AstScope being processed
AstScope* m_scopep = nullptr;
// Sensitivity list for clocked logic, nullptr for combinational and hybird logic
// Sensitivity list for clocked logic, nullptr for combinational and hybrid logic
AstSenTree* m_domainp = nullptr;
// Sensitivity list for hybrid logic, nullptr for everything else
AstSenTree* m_hybridp = nullptr;
@ -810,7 +810,7 @@ class OrderProcess final : VNDeleter {
SenTreeFinder m_finder; // Global AstSenTree manager
AstSenTree* const m_deleteDomainp; // Dummy AstSenTree indicating needs deletion
const string m_tag; // Subtring to add to generated names
const string m_tag; // Substring to add to generated names
const bool m_slow; // Ordering slow code
std::vector<AstNode*> m_result; // The result nodes (~statements) in their sequential order

4
src/V3PairingHeap.h
View File

@ -80,7 +80,7 @@ public:
return result;
}
// Minimal convenience acessors and operators
// Minimal convenience accessors and operators
VL_ATTR_ALWINLINE Node* ptr() const { return m_ptr; }
VL_ATTR_ALWINLINE operator bool() const { return m_ptr; }
VL_ATTR_ALWINLINE bool operator!() const { return !m_ptr; }
@ -214,7 +214,7 @@ public:
if (nodep == m_root.ptr()) return;
// Otherwise we do have a little work to do
if (!nodep->m_kids) {
// If the node has no children, replace it with its siblings (migtht be null)
// If the node has no children, replace it with its siblings (might be null)
nodep->replaceWith(nodep->m_next.unlink());
} else if (!nodep->m_next) {
// If the node has no siblings, replace it with its children

4
src/V3Param.cpp
View File

@ -198,7 +198,7 @@ public:
}
return v3EpsilonEqual(var, hierOptParamp->num().toDouble());
} else { // Now integer type is assumed
// Bitwidth of hierOptParamp is accurate because V3Width already caluclated in the
// Bitwidth of hierOptParamp is accurate because V3Width already calculated in the
// previous run. Bitwidth of pinValuep is before width analysis, so pinValuep is casted
// to hierOptParamp width.
V3Number varNum{pinValuep, hierOptParamp->num().width()};
@ -495,7 +495,7 @@ class ParamProcessor final {
if (varp->isGParam()) {
AstConst* const constp = VN_CAST(varp->valuep(), Const);
// constp can be nullptr if the parameter is not used to instantiate sub
// module. varp->valuep() is not contified yet in the case.
// module. varp->valuep() is not constified yet in the case.
// nullptr means that the parameter is using some default value.
params.emplace(varp->name(), constp);
}

2
src/V3ParseGrammar.cpp
View File

@ -191,7 +191,7 @@ AstVar* V3ParseGrammar::createVariable(FileLine* fileline, const string& name,
}
}
if (type == VVarType::GENVAR) {
// Should be impossible as the grammer blocks this, but...
// Should be impossible as the grammar blocks this, but...
if (arrayp) fileline->v3error("Genvars may not be arrayed: " << name); // LCOV_EXCL_LINE
}

2
src/V3ParseImp.h
View File

@ -240,7 +240,7 @@ public:
}
// Bison sometimes needs error context without a token, so remember last token's line
// Only use this if do not have and cannot get a token-relevent fileline
// Only use this if do not have and cannot get a token-relevant fileline
FileLine* bisonLastFileline() const { return m_bisonLastFileline; }
// Return next token, for bison, since bison isn't class based, use a global THIS

4
src/V3PreProc.cpp
View File

@ -1002,7 +1002,7 @@ int V3PreProcImp::getStateToken() {
if (tok == VP_DEFREF_JOIN) {
// Here's something fun and unspecified as yet:
// The existence of non-existance of a base define changes `` expansion
// The existence of non-existence of a base define changes `` expansion
// `define QA_b zzz
// `define Q1 `QA``_b
// 1Q1 -> zzz
@ -1249,7 +1249,7 @@ int V3PreProcImp::getStateToken() {
refp->nextarg(refp->nextarg() + rtn);
goto next_tok;
} else if (tok == VP_STRIFY) {
// We must expand stringinfication, when done will return to this state
// We must expand stringification, when done will return to this state
statePush(ps_STRIFY);
goto next_tok;
} else {

2
src/V3ProtectLib.cpp
View File

@ -151,7 +151,7 @@ private:
// Timescale
if (v3Global.opt.hierChild() && v3Global.rootp()->timescaleSpecified()) {
// Emit timescale for hierarhical verilation if input HDL specifies timespec
// Emit timescale for hierarchical verilation if input HDL specifies timespec
txtp->addText(fl, std::string{"timeunit "} + modp->timeunit().ascii() + ";\n");
txtp->addText(fl, std::string{"timeprecision "}
+ +v3Global.rootp()->timeprecision().ascii() + ";\n");

2
src/V3Sched.cpp
View File

@ -349,7 +349,7 @@ AstSenTree* createTriggerSenTree(AstNetlist* netlistp, AstVarScope* const vscp,
// Utility for extra trigger allocation
class ExtraTriggers final {
std::vector<string> m_descriptions; // Human readable descirption of extra triggers
std::vector<string> m_descriptions; // Human readable description of extra triggers
public:
ExtraTriggers() = default;

2
src/V3Sched.h
View File

@ -79,7 +79,7 @@ struct LogicClasses final {
LogicByScope m_initial; // initial blocks
LogicByScope m_final; // final blocks
LogicByScope m_comb; // Combinational logic (logic with implicit sensitivities)
LogicByScope m_clocked; // Clocked (or sequential) logic (logic with explictit sensitivities)
LogicByScope m_clocked; // Clocked (or sequential) logic (logic with explicit sensitivities)
LogicByScope m_hybrid; // Hybrid logic (combinational logic with some explicit sensitivities)
LogicByScope m_postponed; // Postponed logic ($strobe)

4
src/V3SenExprBuilder.h
View File

@ -32,7 +32,7 @@ class SenExprBuilder final {
AstScope* const m_scopep; // The scope
std::vector<AstVar*> m_locals; // Trigger eval local variables
std::vector<AstNodeStmt*> m_inits; // Initialization statements for prevoius values
std::vector<AstNodeStmt*> m_inits; // Initialization statements for previous values
std::vector<AstNodeStmt*> m_preUpdates; // Pre update assignments
std::vector<AstNodeStmt*> m_postUpdates; // Post update assignments
@ -40,7 +40,7 @@ class SenExprBuilder final {
std::unordered_map<VNRef<AstNode>, AstVarScope*> m_curr; // The 'current value' signals
std::unordered_set<VNRef<AstNode>> m_hasPreUpdate; // Whether the given sen expression already
// has an update statement in m_preUpdates
std::unordered_set<VNRef<AstNode>> m_hasPostUpdate; // Likewis for m_postUpdates
std::unordered_set<VNRef<AstNode>> m_hasPostUpdate; // Likewise for m_postUpdates
V3UniqueNames m_currNames{"__Vtrigcurrexpr"}; // For generating unique current value
// signal names

6
src/V3SplitVar.cpp
View File

@ -14,9 +14,9 @@
//
//*************************************************************************
// V3SplitVar divides a variable into multiple variables to avoid UNOPTFLAT warning
// and get better perfomance.
// and get better performance.
// Variables to be split must be marked by /*verilator split_var*/ metacomment.
// There are sveral kinds of data types that may cause the warning.
// There are several kinds of data types that may cause the warning.
// 1) Unpacked arrays
// 2) Packed arrays
// 3) Unpacked structs
@ -1142,7 +1142,7 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
}
}
// If varp is an argument of task/func, need to update temporary var
// everytime the var is updated. See also another call of connectPortAndVar() in
// every time the var is updated. See also another call of connectPortAndVar() in
// split()
if (varp->isIO() && (varp->isFuncLocal() || varp->isFuncReturn()))
connectPortAndVar(vars, varp, ref.nodep());

2
src/V3Tristate.cpp
View File

@ -656,7 +656,7 @@ class TristateVisitor final : public TristateBaseVisitor {
void aggregateTriSameStrength(AstNodeModule* nodep, AstVar* const varp, AstVar* const envarp,
RefStrengthVec::iterator beginStrength,
RefStrengthVec::iterator endStrength) {
// For each driver seperate variables (normal and __en) are created and initialized with
// For each driver separate variables (normal and __en) are created and initialized with
// values. In case of normal variable, the original expression is reused. Their values are
// aggregated using | to form one expression, which are assigned to varp end envarp.
AstNodeExpr* orp = nullptr;

2
src/V3Undriven.cpp
View File

@ -386,7 +386,7 @@ private:
if (m_inBBox || nodep->access().isReadOrRW()
|| fdrv
// Inouts have only isWrite set, as we don't have more
// information and operating on module boundry, treat as
// information and operating on module boundary, treat as
// both read and writing
|| m_inInoutPin)
entryp->usedWhole();

8
src/V3Width.cpp
View File

@ -1138,7 +1138,7 @@ private:
if (nodep->didWidthAndSet()) return;
if (m_vup && m_vup->prelim()) {
if (VN_IS(nodep->dtypep()->skipRefToEnump(), EnumDType)) {
// Assume this constant was properly casted ealier
// Assume this constant was properly casted earlier
// (Otherwise it couldn't have an enum data type)
} else if (nodep->num().isString()) {
nodep->dtypeSetString();
@ -1713,7 +1713,7 @@ private:
userIterate(nodep->subDTypep(), nullptr);
nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
nodep->typedefp(nullptr); // Note until line above subDTypep() may have followed this
// Widths are resolved, but special iterate to check for recurstion
// Widths are resolved, but special iterate to check for recursion
userIterate(nodep->subDTypep(), nullptr);
}
// Effectively nodep->dtypeFrom(nodep->dtypeSkipRefp());
@ -1732,7 +1732,7 @@ private:
<< refp->warnOther()
<< "... Location of reference\n"
<< refp->warnContextSecondary());
// May cause internel error but avoids infinite loop on dump
// May cause internal error but avoids infinite loop on dump
refp->typedefp(nullptr);
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
return;
@ -3789,7 +3789,7 @@ private:
const auto it = patmap.find(memp);
AstPatMember* patp = nullptr;
if (it == patmap.end()) {
// default or deafult_type assignment
// default or default_type assignment
if (AstNodeUOrStructDType* const memp_nested_vdtypep
= VN_CAST(memp->virtRefDTypep(), NodeUOrStructDType)) {
newp = nestedvalueConcat_patternUOrStruct(memp_nested_vdtypep, defaultp, newp,