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

Internals: Favor preincrements. No functional change.

This commit is contained in:
Wilson Snyder 2025-05-09 08:25:54 -04:00
parent c2d289dc71
commit 7191a0ba8b
11 changed files with 126 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/verilated.cpp
View File

@ -577,14 +577,14 @@ WDataOutP VL_POW_WWW(int obits, int, int rbits, WDataOutP owp, const WDataInP lw
const int owords = VL_WORDS_I(obits);
VL_DEBUG_IFDEF(assert(owords <= VL_MULS_MAX_WORDS););
owp[0] = 1;
for (int i = 1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
for (int i = 1; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
// cppcheck-has-bug-suppress variableScope
VlWide<VL_MULS_MAX_WORDS> powstore; // Fixed size, as MSVC++ doesn't allow [words] here
VlWide<VL_MULS_MAX_WORDS> lastpowstore; // Fixed size, as MSVC++ doesn't allow [words] here
VlWide<VL_MULS_MAX_WORDS> lastoutstore; // Fixed size, as MSVC++ doesn't allow [words] here
// cppcheck-has-bug-suppress variableScope
VL_ASSIGN_W(obits, powstore, lwp);
for (int bit = 0; bit < rbits; bit++) {
for (int bit = 0; bit < rbits; ++bit) {
if (bit > 0) { // power = power*power
VL_ASSIGN_W(obits, lastpowstore, powstore);
VL_MUL_W(owords, powstore, lastpowstore, lastpowstore);
@ -1770,7 +1770,7 @@ std::string VL_STACKTRACE_N() VL_MT_SAFE {
if (!strings) return "Unable to backtrace\n";
std::string result = "Backtrace:\n";
for (int j = 0; j < nptrs; j++) result += std::string{strings[j]} + "\n"s;
for (int j = 0; j < nptrs; ++j) result += std::string{strings[j]} + "\n"s;
free(strings);
return result;
}
@ -2042,7 +2042,7 @@ static const char* formatBinary(int nBits, uint32_t bits) {
assert((nBits >= 1) && (nBits <= 32));
static thread_local char t_buf[64];
for (int i = 0; i < nBits; i++) {
for (int i = 0; i < nBits; ++i) {
const bool isOne = bits & (1 << (nBits - 1 - i));
t_buf[i] = (isOne ? '1' : '0');
}

2
include/verilated_cov.cpp
View File

@ -312,7 +312,7 @@ public:
const char* fnstartp = m_insertFilenamep;
while (const char* foundp = std::strchr(fnstartp, '/')) fnstartp = foundp + 1;
const char* fnendp = fnstartp;
for (; *fnendp && *fnendp != '.'; fnendp++) {}
for (; *fnendp && *fnendp != '.'; ++fnendp) {}
const size_t page_len = fnendp - fnstartp;
const std::string page_default = "sp_user/" + std::string{fnstartp, page_len};
ckeyps[2] = "page";

2
include/verilated_probdist.cpp
View File

@ -116,7 +116,7 @@ IData VL_DIST_ERLANG(IData& seedr, IData uk, IData umean) VL_MT_SAFE {
return 0;
}
double x = 1.0;
for (int32_t i = 1; i <= k; i++) x = x * _vl_dbase_uniform(seedr, 0, 1);
for (int32_t i = 1; i <= k; ++i) x = x * _vl_dbase_uniform(seedr, 0, 1);
const double a = static_cast<double>(mean);
const double b = static_cast<double>(k);
double r = -a * log(x) / b;

12
include/verilated_random.cpp
View File

@ -112,7 +112,7 @@ public:
if (m_pidStatus) {
std::stringstream msg;
msg << "Subprocess command `" << m_cmd[0];
for (const char* const* arg = m_cmd + 1; *arg; arg++) msg << ' ' << *arg;
for (const char* const* arg = m_cmd + 1; *arg; ++arg) msg << ' ' << *arg;
msg << "' failed: ";
if (WIFSIGNALED(m_pidStatus))
msg << strsignal(WTERMSIG(m_pidStatus))
@ -221,7 +221,7 @@ static Process& getSolver() {
static std::vector<const char*> s_argv;
static std::string s_program = Verilated::threadContextp()->solverProgram();
s_argv.emplace_back(&s_program[0]);
for (char* arg = &s_program[0]; *arg; arg++) {
for (char* arg = &s_program[0]; *arg; ++arg) {
if (*arg == ' ') {
*arg = '\0';
s_argv.emplace_back(arg + 1);
@ -242,7 +242,7 @@ static Process& getSolver() {
msg << "Unable to communicate with SAT solver, please check its installation or specify a "
"different one in VERILATOR_SOLVER environment variable.\n";
msg << " ... Tried: $";
for (const char* const* arg = cmd; *arg; arg++) msg << ' ' << *arg;
for (const char* const* arg = cmd; *arg; ++arg) msg << ' ' << *arg;
msg << '\n';
const std::string str = msg.str();
VL_WARN_MT("", 0, "randomize", str.c_str());
@ -294,7 +294,7 @@ void VlRandomVar::emitType(std::ostream& s) const { s << "(_ BitVec " << width()
int VlRandomVar::totalWidth() const { return m_width; }
static bool parseSMTNum(int obits, WDataOutP owp, const std::string& val) {
int i;
for (i = 0; val[i] && val[i] != '#'; i++) {}
for (i = 0; val[i] && val[i] != '#'; ++i) {}
if (val[i++] != '#') return false;
switch (val[i++]) {
case 'b': _vl_vsss_based(owp, obits, 1, &val[i], 0, val.size() - i); break;
@ -345,7 +345,7 @@ void VlRandomizer::randomConstraint(std::ostream& os, VlRNG& rngr, int bits) {
os << "(= #b";
for (int i = bits - 1; i >= 0; i--) os << (VL_BITISSET_I(hash, i) ? '1' : '0');
if (bits > 1) os << " (concat";
for (int i = 0; i < bits; i++) {
for (int i = 0; i < bits; ++i) {
IData varBitsLeft = varBits;
IData varBitsWant = (varBits + 1) / 2;
if (varBits > 2) os << " (bvxor";
@ -393,7 +393,7 @@ bool VlRandomizer::next(VlRNG& rngr) {
f << "(reset)\n";
return false;
}
for (int i = 0; i < _VL_SOLVER_HASH_LEN_TOTAL && sat; i++) {
for (int i = 0; i < _VL_SOLVER_HASH_LEN_TOTAL && sat; ++i) {
f << "(assert ";
randomConstraint(f, rngr, _VL_SOLVER_HASH_LEN);
f << ")\n";

2
include/verilated_random.h
View File

@ -143,7 +143,7 @@ public:
}
void emitGetValue(std::ostream& s) const override {
const int elementCounts = countMatchingElements(*m_arrVarsRefp, name());
for (int i = 0; i < elementCounts; i++) {
for (int i = 0; i < elementCounts; ++i) {
const std::string indexed_name = name() + std::to_string(i);
const auto it = m_arrVarsRefp->find(indexed_name);
if (it != m_arrVarsRefp->end()) {

2
include/verilated_saif_c.cpp
View File

@ -110,7 +110,7 @@ public:
"The emitted value must be of integral type");
const uint64_t dt = time - m_lastTime;
for (size_t i = 0; i < std::min(m_width, bits); i++) {
for (size_t i = 0; i < std::min(m_width, bits); ++i) {
m_bits[i].aggregateVal(dt, (newval >> i) & 1);
}
updateLastTime(time);

2
include/verilated_trace_imp.h
View File

@ -47,7 +47,7 @@ static double timescaleToDouble(const char* unitp) VL_PURE {
// On error so we allow just "ns" to return 1e-9.
if (value == 0.0 && endp == unitp) value = 1;
unitp = endp;
for (; *unitp && std::isspace(*unitp); unitp++) {}
for (; *unitp && std::isspace(*unitp); ++unitp) {}
switch (*unitp) {
case 's': value *= 1e0; break;
case 'm': value *= 1e-3; break;

32
include/verilated_vpi.cpp
View File

@ -205,7 +205,7 @@ public:
uint32_t size() const override {
const int maxDimNum = maxDim(isIndexedDimUnpacked());
int size = 1;
for (int dim = indexedDim() + 1; dim <= maxDimNum; dim++)
for (int dim = indexedDim() + 1; dim <= maxDimNum; ++dim)
size *= varp()->range(dim)->elements();
return size;
}
@ -503,7 +503,7 @@ public:
explicit VerilatedVpioRegIter(const VerilatedVpioVar* vop)
: m_var{new VerilatedVpioVar(vop)}
, m_maxDim{vop->varp()->udims() - 1} {
for (auto it = vop->indexedDim() + 1; it <= m_maxDim; it++)
for (auto it = vop->indexedDim() + 1; it <= m_maxDim; ++it)
m_ranges.push_back(*vop->varp()->range(it));
for (auto it : m_ranges) m_nextIndex.push_back(it.right());
}
@ -2219,7 +2219,7 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
std::vector<VerilatedRange> ranges;
const int maxDim = vop->maxDim(vop->isIndexedDimUnpacked());
for (int dim = vop->indexedDim() + 1; dim <= maxDim; dim++)
for (int dim = vop->indexedDim() + 1; dim <= maxDim; ++dim)
ranges.emplace_back(*vop->varp()->range(dim));
// allow one more range layer (regbit)
@ -2945,7 +2945,7 @@ void vl_get_value_array_integrals(unsigned index, const unsigned num, const unsi
const unsigned packedSize, const bool leftIsLow, const T* src,
K* dst) {
static_assert(sizeof(K) >= sizeof(T), "size of type K is less than size of type T");
for (int i = 0; i < num; i++) {
for (int i = 0; i < num; ++i) {
dst[i] = src[index];
index = leftIsLow ? index == (size - 1) ? 0 : index + 1
: index == 0 ? size - 1
@ -2964,7 +2964,7 @@ void vl_put_value_array_integrals(unsigned index, const unsigned num, const unsi
const T mask = element_size_bytes == sizeof(T)
? static_cast<T>(-1)
: ~(static_cast<T>(-1) << (element_size_bytes * 8));
for (unsigned i = 0; i < num; i++) {
for (unsigned i = 0; i < num; ++i) {
dst[index] = src[i] & static_cast<T>(mask);
index = leftIsLow ? index == (size - 1) ? 0 : index + 1
: index == 0 ? size - 1
@ -2981,7 +2981,7 @@ void vl_get_value_array_vectors(unsigned index, const unsigned num, const unsign
const unsigned element_size_bytes = VL_BYTES_I(packedSize);
const unsigned element_size_words = VL_WORDS_I(packedSize);
if (sizeof(T) == sizeof(QData)) {
for (unsigned i = 0; i < num; i++) {
for (unsigned i = 0; i < num; ++i) {
dst[i * 2].aval = static_cast<QData>(src[index]);
dst[i * 2].bval = 0;
dst[(i * 2) + 1].aval = static_cast<QData>(src[index]) >> 32;
@ -2991,10 +2991,10 @@ void vl_get_value_array_vectors(unsigned index, const unsigned num, const unsign
: index - 1;
}
} else {
for (unsigned i = 0; i < num; i++) {
for (unsigned i = 0; i < num; ++i) {
const size_t dst_index = i * element_size_words;
const size_t src_index = index * element_size_words;
for (unsigned j = 0; j < element_size_words; j++) {
for (unsigned j = 0; j < element_size_words; ++j) {
dst[dst_index + j].aval = src[src_index + j];
dst[dst_index + j].bval = 0;
}
@ -3017,7 +3017,7 @@ void vl_put_value_array_vectors(unsigned index, const unsigned num, const unsign
const QData mask = element_size_bytes == sizeof(T)
? static_cast<QData>(-1)
: ~(static_cast<QData>(-1) << (element_size_bytes * 8));
for (unsigned i = 0; i < num; i++) {
for (unsigned i = 0; i < num; ++i) {
dst[index] = src[i * 2].aval;
dst[index]
|= (static_cast<QData>(src[(i * 2) + 1].aval) << (sizeof(PLI_UINT32) * 8)) & mask;
@ -3026,9 +3026,9 @@ void vl_put_value_array_vectors(unsigned index, const unsigned num, const unsign
: index - 1;
}
} else {
for (unsigned i = 0; i < num; i++) {
for (unsigned i = 0; i < num; ++i) {
unsigned bytes_stored = 0;
for (unsigned j = 0; j < element_size_words; j++) {
for (unsigned j = 0; j < element_size_words; ++j) {
if (bytes_stored >= element_size_bytes) break;
const T mask
= (element_size_bytes - bytes_stored) >= sizeof(PLI_UINT32)
@ -3057,9 +3057,9 @@ void vl_get_value_array_rawvals(unsigned index, unsigned num, const unsigned siz
while (num-- > 0) {
const size_t src_offset = index * element_size_repr;
unsigned bytes_copied = 0;
for (unsigned j = 0; j < element_size_repr; j++) {
for (unsigned j = 0; j < element_size_repr; ++j) {
const T& src_data = src[src_offset + j];
for (unsigned k = 0; k < sizeof(T); k++) {
for (unsigned k = 0; k < sizeof(T); ++k) {
if (bytes_copied++ == element_size_bytes) break;
dst[dst_index++] = src_data >> (k * 8);
}
@ -3080,13 +3080,13 @@ void vl_put_value_array_rawvals(unsigned index, const unsigned num, const unsign
const bool fourState, const PLI_UBYTE8* src, T* dst) {
const unsigned element_size_bytes VL_BYTES_I(packedSize);
const unsigned element_size_repr = (element_size_bytes + sizeof(T) - 1) / sizeof(T);
for (unsigned i = 0; i < num; i++) {
for (unsigned i = 0; i < num; ++i) {
unsigned bytes_copied = 0;
const size_t dst_offset = index * element_size_repr;
const size_t src_offset = i * element_size_bytes;
for (unsigned j = 0; j < element_size_repr; j++) {
for (unsigned j = 0; j < element_size_repr; ++j) {
T& dst_data = dst[dst_offset + j];
for (unsigned k = 0; k < sizeof(T); k++) {
for (unsigned k = 0; k < sizeof(T); ++k) {
if (bytes_copied == element_size_bytes) break;
const unsigned src_index
= fourState ? (src_offset * 2) + bytes_copied : (src_offset) + bytes_copied;

186
src/V3Number.cpp
View File

@ -128,7 +128,7 @@ V3Number::V3Number(AstNode* nodep, const AstNodeDType* nodedtypep) {
void V3Number::create(const char* sourcep) {
m_data.setLogic();
const char* value_startp = sourcep;
for (const char* cp = sourcep; *cp; cp++) {
for (const char* cp = sourcep; *cp; ++cp) {
if (*cp == '\'') {
value_startp = cp + 1;
break;
@ -141,21 +141,21 @@ void V3Number::create(const char* sourcep) {
if (value_startp != sourcep) { // Has a '
string widthn;
const char* cp = sourcep;
for (; *cp; cp++) {
for (; *cp; ++cp) {
if (*cp == '\'') {
cp++;
++cp;
break;
}
if (*cp != '_') widthn += *cp;
}
while (*cp == '_') cp++;
if (*cp && std::tolower(*cp) == 's') {
cp++;
++cp;
isSigned(true);
}
if (*cp) {
base = *cp;
cp++;
++cp;
}
value_startp = cp;
@ -221,14 +221,14 @@ void V3Number::create(const char* sourcep) {
int base_align = 1;
if (std::tolower(base) == 'd') {
// Ignore leading zeros so we don't issue too many digit errors when lots of leading 0's
while (*value_startp == '_' || *value_startp == '0') value_startp++;
while (*value_startp == '_' || *value_startp == '0') ++value_startp;
// Convert decimal number to hex
int olen = 0;
uint32_t val = 0;
int got_x = 0;
int got_z = 0;
int got_01 = 0;
for (const char* cp = value_startp; *cp; cp++) {
for (const char* cp = value_startp; *cp; ++cp) {
switch (std::tolower(*cp)) {
case '0': // FALLTHRU
case '1': // FALLTHRU
@ -254,10 +254,10 @@ void V3Number::create(const char* sourcep) {
opAdd(product, addend);
if (product.bitsValue(width(), 4)) { // Overflowed
warnTooMany(sourcep);
while (*(cp + 1)) cp++; // Skip ahead so don't get multiple warnings
while (*(cp + 1)) ++cp; // Skip ahead so don't get multiple warnings
}
}
olen++;
++olen;
got_01 = 1;
break;
}
@ -344,7 +344,7 @@ void V3Number::create(const char* sourcep) {
case '7': setBit(obit++,1); setBit(obit++,1); setBit(obit++,1); setBit(obit++,0); break;
case '8': setBit(obit++,0); setBit(obit++,0); setBit(obit++,0); setBit(obit++,1); break;
case '9': setBit(obit++,1); setBit(obit++,0); setBit(obit++,0); setBit(obit++,1); break;
case 'a': setBit(obit++,0); setBit(obit++,1); setBit(obit++,0); setBit(obit++,1); break;
case 'a': setBit(obit++,0); setBit(obit++,1); setBit(obit++,0); setBit(obit++,1); break;
case 'b': setBit(obit++,1); setBit(obit++,1); setBit(obit++,0); setBit(obit++,1); break;
case 'c': setBit(obit++,0); setBit(obit++,0); setBit(obit++,1); setBit(obit++,1); break;
case 'd': setBit(obit++,1); setBit(obit++,0); setBit(obit++,1); setBit(obit++,1); break;
@ -379,7 +379,7 @@ void V3Number::create(const char* sourcep) {
// This fixes 2'bx to become 2'bxx.
while (obit <= width() && obit && bitIsXZ(obit - 1)) {
setBit(obit, bitIs(obit - 1));
obit++;
++obit;
}
opCleanThis(true);
@ -428,24 +428,24 @@ int V3Number::log2bQuad(uint64_t num) {
// Setters
V3Number& V3Number::setZero() {
for (int i = 0; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {0, 0};
return *this;
}
V3Number& V3Number::setQuad(uint64_t value) {
for (int i = 0; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {0, 0};
m_data.num()[0].m_value = value & 0xffffffffULL;
if (width() > 32) m_data.num()[1].m_value = (value >> 32ULL) & 0xffffffffULL;
opCleanThis();
return *this;
}
V3Number& V3Number::setLong(uint32_t value) {
for (int i = 0; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {0, 0};
m_data.num()[0].m_value = value;
opCleanThis();
return *this;
}
V3Number& V3Number::setLongS(int32_t value) {
for (int i = 0; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {0, 0};
union {
uint32_t u;
int32_t s;
@ -465,35 +465,35 @@ V3Number& V3Number::setDouble(double value) {
} u;
u.d = value;
(void)u.d;
for (int i = 2; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 2; i < words(); ++i) m_data.num()[i] = {0, 0};
m_data.num()[0].m_value = u.u[0];
m_data.num()[1].m_value = u.u[1];
return *this;
}
V3Number& V3Number::setSingleBits(char value) {
for (int i = 1 /*upper*/; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 1 /*upper*/; i < words(); ++i) m_data.num()[i] = {0, 0};
m_data.num()[0] = {(value == '1' || value == 'x' || value == 1 || value == 3),
(value == 'z' || value == 'x' || value == 2 || value == 3)};
return *this;
}
V3Number& V3Number::setAllBits0() {
for (int i = 0; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {0, 0};
return *this;
}
V3Number& V3Number::setAllBits1() {
for (int i = 0; i < words(); i++) m_data.num()[i] = {~0U, 0};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {~0U, 0};
opCleanThis();
return *this;
}
V3Number& V3Number::setAllBitsX() {
// Use setAllBitsXRemoved if calling this based on a non-X/Z input value such as divide by zero
for (int i = 0; i < words(); i++) m_data.num()[i] = {~0U, ~0U};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {~0U, ~0U};
opCleanThis();
return *this;
}
V3Number& V3Number::setAllBitsZ() {
for (int i = 0; i < words(); i++) m_data.num()[i] = {0, ~0U};
for (int i = 0; i < words(); ++i) m_data.num()[i] = {0, ~0U};
opCleanThis();
return *this;
}
@ -512,7 +512,7 @@ V3Number& V3Number::setAllBitsXRemoved() {
}
V3Number& V3Number::setValue1() {
m_data.num()[0] = {1, 0};
for (int i = 1; i < words(); i++) m_data.num()[i] = {0, 0};
for (int i = 1; i < words(); ++i) m_data.num()[i] = {0, 0};
return *this;
}
@ -524,7 +524,7 @@ void V3Number::setBitX0(int bit) {
V3Number& V3Number::setMask(int nbits, int lsb) {
setZero();
for (int bit = lsb; bit < lsb + nbits; bit++) setBit(bit, 1);
for (int bit = lsb; bit < lsb + nbits; ++bit) setBit(bit, 1);
return *this;
}
@ -759,7 +759,7 @@ string V3Number::displayed(FileLine* fl, const string& vformat) const VL_MT_STAB
// Spec says always drop leading zeros, this isn't quite right, we space pad.
int bit = width() - 1;
bool start = true;
while ((bit % 8) != 7) bit++;
while ((bit % 8) != 7) ++bit;
for (; bit >= 0; bit -= 8) {
const int v = bitsValue(bit - 7, 8);
if (!start || v) {
@ -784,7 +784,7 @@ string V3Number::displayed(FileLine* fl, const string& vformat) const VL_MT_STAB
// a very wide mantissa, we use log2(2**mantissabits)/log2(10),
// which is (+1.0 is for rounding bias):
double dchars = mantissabits / 3.321928094887362 + 1.0;
if (issigned) dchars++; // space for sign
if (issigned) ++dchars; // space for sign
fmtsize = cvtToStr(int(dchars));
}
bool hasXZ = false;
@ -833,7 +833,7 @@ string V3Number::displayed(FileLine* fl, const string& vformat) const VL_MT_STAB
// 'l' // Library - converted to text by V3LinkResolve
// 'p' // Packed - converted to another code by V3Width
case 'u': { // Packed 2-state
for (int i = 0; i < words(); i++) {
for (int i = 0; i < words(); ++i) {
const uint32_t v = m_data.num()[i].m_value;
str += static_cast<char>((v >> 0) & 0xff);
str += static_cast<char>((v >> 8) & 0xff);
@ -843,7 +843,7 @@ string V3Number::displayed(FileLine* fl, const string& vformat) const VL_MT_STAB
return str;
}
case 'z': { // Packed 4-state
for (int i = 0; i < words(); i++) {
for (int i = 0; i < words(); ++i) {
const ValueAndX v = m_data.num()[i];
str += static_cast<char>((v.m_value >> 0) & 0xff);
str += static_cast<char>((v.m_value >> 8) & 0xff);
@ -1039,7 +1039,7 @@ uint8_t V3Number::dataByte(int byte) const {
bool V3Number::isAllZ() const VL_MT_SAFE {
if (isDouble() || isString()) return false;
for (int i = 0; i < width(); i++) {
for (int i = 0; i < width(); ++i) {
if (!bitIsZ(i)) return false;
}
return true;
@ -1056,7 +1056,7 @@ bool V3Number::isAllX() const VL_MT_SAFE {
}
bool V3Number::isEqZero() const VL_MT_SAFE {
if (isString()) return m_data.str().empty();
for (int i = 0; i < words(); i++) {
for (int i = 0; i < words(); ++i) {
const ValueAndX v = m_data.num()[i];
if (v.m_value || v.m_valueX) return false;
}
@ -1064,21 +1064,21 @@ bool V3Number::isEqZero() const VL_MT_SAFE {
}
bool V3Number::isNeqZero() const {
if (isString()) return !m_data.str().empty();
for (int i = 0; i < words(); i++) {
for (int i = 0; i < words(); ++i) {
const ValueAndX v = m_data.num()[i];
if (v.m_value & ~v.m_valueX) return true;
}
return false;
}
bool V3Number::isBitsZero(int msb, int lsb) const {
for (int i = lsb; i <= msb; i++) {
for (int i = lsb; i <= msb; ++i) {
if (VL_UNLIKELY(!bitIs0(i))) return false;
}
return true;
}
bool V3Number::isEqOne() const {
if (m_data.num()[0].m_value != 1 || m_data.num()[0].m_valueX) return false;
for (int i = 1; i < words(); i++) {
for (int i = 1; i < words(); ++i) {
const ValueAndX v = m_data.num()[i];
if (v.m_value || v.m_valueX) return false;
}
@ -1087,7 +1087,7 @@ bool V3Number::isEqOne() const {
bool V3Number::isEqAllOnes(int optwidth) const {
// Correct number of zero bits/width matters
if (!optwidth) optwidth = width();
for (int bit = 0; bit < optwidth; bit++) {
for (int bit = 0; bit < optwidth; ++bit) {
if (!bitIs1(bit)) return false;
}
return true;
@ -1101,7 +1101,7 @@ bool V3Number::isFourState() const VL_MT_SAFE {
}
bool V3Number::isAnyX() const VL_MT_SAFE {
if (isDouble() || isString()) return false;
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (bitIsX(bit)) return true;
}
return false;
@ -1109,14 +1109,14 @@ bool V3Number::isAnyX() const VL_MT_SAFE {
bool V3Number::isAnyXZ() const { return isAnyX() || isAnyZ(); }
bool V3Number::isAnyZ() const VL_MT_SAFE {
if (isDouble() || isString()) return false;
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (bitIsZ(bit)) return true;
}
return false;
}
bool V3Number::isLtXZ(const V3Number& rhs) const {
// Include X/Z in comparisons for sort ordering
for (int bit = 0; bit < std::max(width(), rhs.width()); bit++) {
for (int bit = 0; bit < std::max(width(), rhs.width()); ++bit) {
if (bitIs1(bit) && rhs.bitIs0(bit)) return true;
if (rhs.bitIs1(bit) && bitIs0(bit)) return false;
if (bitIsXZ(bit)) return true;
@ -1183,8 +1183,8 @@ uint32_t V3Number::countBits(const V3Number& ctrl1, const V3Number& ctrl2,
uint32_t V3Number::countOnes() const {
int n = 0;
for (int bit = 0; bit < width(); bit++) {
if (bitIs1(bit)) n++;
for (int bit = 0; bit < width(); ++bit) {
if (bitIs1(bit)) ++n;
}
return n;
}
@ -1203,7 +1203,7 @@ V3Number& V3Number::opBitsNonX(const V3Number& lhs) { // 0/1->1, X/Z->0
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIs0(bit) || lhs.bitIs1(bit)) setBit(bit, 1);
}
return *this;
@ -1213,7 +1213,7 @@ V3Number& V3Number::opBitsOne(const V3Number& lhs) { // 1->1, 0/X/Z->0
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIs1(bit)) setBit(bit, 1);
}
return *this;
@ -1223,7 +1223,7 @@ V3Number& V3Number::opBitsXZ(const V3Number& lhs) { // 0/1->1, X/Z->0
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIsXZ(bit)) setBit(bit, 1);
}
return *this;
@ -1233,7 +1233,7 @@ V3Number& V3Number::opBitsZ(const V3Number& lhs) { // 0/1->1, X/Z->0
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIsZ(bit)) setBit(bit, 1);
}
return *this;
@ -1247,7 +1247,7 @@ V3Number& V3Number::opRedOr(const V3Number& lhs) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
char outc = 0;
for (int bit = 0; bit < lhs.width(); bit++) {
for (int bit = 0; bit < lhs.width(); ++bit) {
if (lhs.bitIs1(bit)) {
return setSingleBits(1);
} else if (lhs.bitIs0(bit)) {
@ -1264,7 +1264,7 @@ V3Number& V3Number::opRedAnd(const V3Number& lhs) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
char outc = 1;
for (int bit = 0; bit < lhs.width(); bit++) {
for (int bit = 0; bit < lhs.width(); ++bit) {
if (lhs.bitIs0(bit)) {
return setSingleBits(0);
} else if (lhs.bitIs1(bit)) {
@ -1280,7 +1280,7 @@ V3Number& V3Number::opRedXor(const V3Number& lhs) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
char outc = 0;
for (int bit = 0; bit < lhs.width(); bit++) {
for (int bit = 0; bit < lhs.width(); ++bit) {
if (lhs.bitIs1(bit)) {
if (outc == 1) {
outc = 0;
@ -1349,7 +1349,7 @@ V3Number& V3Number::opLogNot(const V3Number& lhs) {
NUM_ASSERT_LOGIC_ARGS1(lhs);
// op i, 1 bit return
char outc = 1;
for (int bit = 0; bit < lhs.width(); bit++) {
for (int bit = 0; bit < lhs.width(); ++bit) {
if (lhs.bitIs1(bit)) {
outc = 0;
goto last;
@ -1368,7 +1368,7 @@ V3Number& V3Number::opNot(const V3Number& lhs) {
NUM_ASSERT_LOGIC_ARGS1(lhs);
// op i, L(lhs) bit return
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIs0(bit)) {
setBit(bit, 1);
} else if (lhs.bitIsXZ(bit)) {
@ -1383,7 +1383,7 @@ V3Number& V3Number::opAnd(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
// i op j, max(L(lhs),L(rhs)) bit return, careful need to X/Z extend.
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIs1(bit) && rhs.bitIs1(bit)) {
setBit(bit, 1);
} else if (lhs.bitIs0(bit) || rhs.bitIs0(bit)) { // 0
@ -1399,7 +1399,7 @@ V3Number& V3Number::opOr(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
// i op j, max(L(lhs),L(rhs)) bit return, careful need to X/Z extend.
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIs1(bit) || rhs.bitIs1(bit)) {
setBit(bit, 1);
} else if (lhs.bitIs0(bit) && rhs.bitIs0(bit)) {
@ -1416,7 +1416,7 @@ V3Number& V3Number::opXor(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_OP_ARGS2(lhs, rhs);
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (lhs.bitIs1(bit) && rhs.bitIs0(bit)) {
setBit(bit, 1);
} else if (lhs.bitIs0(bit) && rhs.bitIs1(bit)) {
@ -1439,13 +1439,13 @@ V3Number& V3Number::opConcat(const V3Number& lhs, const V3Number& rhs) {
v3warn(WIDTHCONCAT, "Unsized numbers/parameters not allowed in concatenations.");
}
int obit = 0;
for (int bit = 0; bit < rhs.width(); bit++) {
for (int bit = 0; bit < rhs.width(); ++bit) {
setBit(obit, rhs.bitIs(bit));
obit++;
++obit;
}
for (int bit = 0; bit < lhs.width(); bit++) {
for (int bit = 0; bit < lhs.width(); ++bit) {
setBit(obit, lhs.bitIs(bit));
obit++;
++obit;
}
return *this;
}
@ -1504,7 +1504,7 @@ V3Number& V3Number::opStreamL(const V3Number& lhs, const V3Number& rhs) {
const int ssize = std::min(rhs.toUInt(), static_cast<unsigned>(lhs.width()));
for (int istart = 0; istart < lhs.width(); istart += ssize) {
const int ostart = std::max(0, lhs.width() - ssize - istart);
for (int bit = 0; bit < ssize && bit < lhs.width() - istart; bit++) {
for (int bit = 0; bit < ssize && bit < lhs.width() - istart; ++bit) {
setBit(ostart + bit, lhs.bitIs(istart + bit));
}
}
@ -1517,14 +1517,14 @@ V3Number& V3Number::opLogAnd(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
char loutc = 0;
char routc = 0;
for (int bit = 0; bit < lhs.width(); bit++) {
for (int bit = 0; bit < lhs.width(); ++bit) {
if (lhs.bitIs1(bit)) {
loutc = 1;
break;
}
if (lhs.bitIsXZ(bit) && loutc == 0) loutc = 'x';
}
for (int bit = 0; bit < rhs.width(); bit++) {
for (int bit = 0; bit < rhs.width(); ++bit) {
if (rhs.bitIs1(bit)) {
routc = 1;
break;
@ -1542,14 +1542,14 @@ V3Number& V3Number::opLogOr(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_OP_ARGS2(lhs, rhs);
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
char outc = 0;
for (int bit = 0; bit < lhs.width(); bit++) {
for (int bit = 0; bit < lhs.width(); ++bit) {
if (lhs.bitIs1(bit)) {
outc = 1;
goto last;
}
if (lhs.bitIsXZ(bit) && outc == 0) outc = 'x';
}
for (int bit = 0; bit < rhs.width(); bit++) {
for (int bit = 0; bit < rhs.width(); ++bit) {
if (rhs.bitIs1(bit)) {
outc = 1;
goto last;
@ -1658,7 +1658,7 @@ V3Number& V3Number::opEq(const V3Number& lhs, const V3Number& rhs) {
if (lhs.isString()) return opEqN(lhs, rhs);
if (lhs.isDouble()) return opEqD(lhs, rhs);
char outc = 1;
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); bit++) {
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); ++bit) {
if (lhs.bitIs1(bit) && rhs.bitIs0(bit)) {
outc = 0;
goto last;
@ -1680,7 +1680,7 @@ V3Number& V3Number::opNeq(const V3Number& lhs, const V3Number& rhs) {
if (lhs.isString()) return opNeqN(lhs, rhs);
if (lhs.isDouble()) return opNeqD(lhs, rhs);
char outc = 0;
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); bit++) {
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); ++bit) {
if (lhs.bitIs1(bit) && rhs.bitIs0(bit)) {
outc = 1;
goto last;
@ -1721,7 +1721,7 @@ V3Number& V3Number::opCaseNeq(const V3Number& lhs, const V3Number& rhs) {
} else if (lhs.isDouble()) {
return opNeqD(lhs, rhs);
}
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); bit++) {
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); ++bit) {
if (lhs.bitIs(bit) != rhs.bitIs(bit)) {
outc = 1;
goto last;
@ -1735,7 +1735,7 @@ V3Number& V3Number::opWildEq(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_OP_ARGS2(lhs, rhs);
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
char outc = 1;
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); bit++) {
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); ++bit) {
if (!rhs.bitIsXZ(bit)) {
if (lhs.bitIs(bit) != rhs.bitIs(bit)) {
outc = 0;
@ -1752,7 +1752,7 @@ V3Number& V3Number::opWildNeq(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_OP_ARGS2(lhs, rhs);
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
char outc = 0;
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); bit++) {
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); ++bit) {
if (!rhs.bitIsXZ(bit)) {
if (lhs.bitIs(bit) != rhs.bitIs(bit)) {
outc = 1;
@ -1770,7 +1770,7 @@ V3Number& V3Number::opGt(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_OP_ARGS2(lhs, rhs);
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
char outc = 0;
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); bit++) {
for (int bit = 0; bit < std::max(lhs.width(), rhs.width()); ++bit) {
if (lhs.bitIs1(bit) && rhs.bitIs0(bit)) outc = 1;
if (rhs.bitIs1(bit) && lhs.bitIs0(bit)) outc = 0;
if (lhs.bitIsXZ(bit)) outc = 'x';
@ -1796,7 +1796,7 @@ V3Number& V3Number::opGtS(const V3Number& lhs, const V3Number& rhs) {
outc = 0; // - !> +
} else {
// both positive or negative, normal >
for (int bit = 0; bit < std::max(lhs.width() - 1, rhs.width() - 1); bit++) {
for (int bit = 0; bit < std::max(lhs.width() - 1, rhs.width() - 1); ++bit) {
if (lhs.bitIs1Extend(bit) && rhs.bitIs0(bit)) outc = 1;
if (rhs.bitIs1Extend(bit) && lhs.bitIs0(bit)) outc = 0;
if (lhs.bitIsXZ(bit)) outc = 'x';
@ -1834,12 +1834,12 @@ V3Number& V3Number::opShiftR(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
if (rhs.isFourState()) return setAllBitsX();
setZero();
for (int bit = 32; bit < rhs.width(); bit++) {
for (int bit = 32; bit < rhs.width(); ++bit) {
if (rhs.bitIs1(bit)) return *this; // shift of over 2^32 must be zero
}
const uint32_t rhsval = rhs.toUInt();
if (rhsval < static_cast<uint32_t>(lhs.width())) {
for (int bit = 0; bit < width(); bit++) setBit(bit, lhs.bitIs(bit + rhsval));
for (int bit = 0; bit < width(); ++bit) setBit(bit, lhs.bitIs(bit + rhsval));
}
return *this;
}
@ -1853,8 +1853,8 @@ V3Number& V3Number::opShiftRS(const V3Number& lhs, const V3Number& rhs, uint32_t
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
if (rhs.isFourState()) return setAllBitsX();
setZero();
for (int bit = 32; bit < rhs.width(); bit++) {
for (int sbit = 0; sbit < width(); sbit++) {
for (int bit = 32; bit < rhs.width(); ++bit) {
for (int sbit = 0; sbit < width(); ++sbit) {
setBit(sbit, lhs.bitIs(lbits - 1)); // 0/1/X/Z
}
if (rhs.bitIs1(lbits - 1)) setAllBits1(); // -1 else 0
@ -1862,11 +1862,11 @@ V3Number& V3Number::opShiftRS(const V3Number& lhs, const V3Number& rhs, uint32_t
}
const uint32_t rhsval = rhs.toUInt();
if (rhsval < static_cast<uint32_t>(lhs.width())) {
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
setBit(bit, lhs.bitIsExtend(bit + rhsval, lbits));
}
} else {
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
setBit(bit, lhs.bitIs(lbits - 1)); // 0/1/X/Z
}
}
@ -1879,11 +1879,11 @@ V3Number& V3Number::opShiftL(const V3Number& lhs, const V3Number& rhs) {
NUM_ASSERT_LOGIC_ARGS2(lhs, rhs);
if (rhs.isFourState()) return setAllBitsX();
setZero();
for (int bit = 32; bit < rhs.width(); bit++) {
for (int bit = 32; bit < rhs.width(); ++bit) {
if (rhs.bitIs1(bit)) return *this; // shift of over 2^32 must be zero
}
const uint32_t rhsval = rhs.toUInt();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (bit >= static_cast<int>(rhsval)) setBit(bit, lhs.bitIs(bit - rhsval));
}
return *this;
@ -1912,7 +1912,7 @@ V3Number& V3Number::opAdd(const V3Number& lhs, const V3Number& rhs) {
setZero();
// Addem
uint64_t carry = 0;
for (int word = 0; word < words(); word++) {
for (int word = 0; word < words(); ++word) {
const uint64_t lwordval = lhs.m_data.num()[word].m_value;
const uint64_t rwordval = rhs.m_data.num()[word].m_value;
const uint64_t sum = lwordval + rwordval + carry;
@ -1942,14 +1942,14 @@ V3Number& V3Number::opMul(const V3Number& lhs, const V3Number& rhs) {
setQuad(lhs.toUQuad() * rhs.toUQuad());
opCleanThis(); // Mult produces extra bits in result
} else {
for (int lword = 0; lword < lhs.words(); lword++) {
for (int lword = 0; lword < lhs.words(); ++lword) {
const uint64_t lwordval = static_cast<uint64_t>(lhs.m_data.num()[lword].m_value);
if (lwordval == 0) continue;
for (int rword = 0; rword < rhs.words(); rword++) {
for (int rword = 0; rword < rhs.words(); ++rword) {
const uint64_t rwordval = static_cast<uint64_t>(rhs.m_data.num()[rword].m_value);
if (rwordval == 0) continue;
uint64_t mul = lwordval * rwordval;
for (int qword = lword + rword; qword < words(); qword++) {
for (int qword = lword + rword; qword < words(); ++qword) {
mul += static_cast<uint64_t>(m_data.num()[qword].m_value);
m_data.num()[qword].m_value = (mul & 0xffffffffULL);
mul = (mul >> 32ULL) & 0xffffffffULL;
@ -2093,8 +2093,8 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
uint32_t vn[VL_MULS_MAX_WORDS + 1]; // v normalized
// Zero for ease of debugging and to save having to zero for shifts
for (int i = 0; i < words; i++) m_data.num()[i].m_value = 0;
for (int i = 0; i < words + 1; i++) { un[i] = vn[i] = 0; } // +1 as vn may get extra word
for (int i = 0; i < words; ++i) m_data.num()[i].m_value = 0;
for (int i = 0; i < words + 1; ++i) { un[i] = vn[i] = 0; } // +1 as vn may get extra word
// Algorithm requires divisor MSB to be set
// Copy and shift to normalize divisor so MSB of vn[vw-1] is set
@ -2139,7 +2139,7 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
int64_t t = 0; // Must be signed
uint64_t k = 0;
for (int i = 0; i < vw; i++) {
for (int i = 0; i < vw; ++i) {
const uint64_t p = qhat * vn[i]; // Multiply by estimate
t = un[i + j] - k - (p & 0xFFFFFFFFULL); // Subtract
un[i + j] = t;
@ -2153,7 +2153,7 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
// Over subtracted; correct by adding back
m_data.num()[j].m_value--;
k = 0;
for (int i = 0; i < vw; i++) {
for (int i = 0; i < vw; ++i) {
t = static_cast<uint64_t>(un[i + j]) + static_cast<uint64_t>(vn[i]) + k;
un[i + j] = t;
k = t >> 32ULL;
@ -2168,10 +2168,10 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
if (is_modulus) { // modulus
// Need to reverse normalization on copy to output
for (int i = 0; i < vw; i++) {
for (int i = 0; i < vw; ++i) {
m_data.num()[i].m_value = (un[i] >> s) | (shift_mask & (un[i + 1] << (32 - s)));
}
for (int i = vw; i < words; i++) m_data.num()[i].m_value = 0;
for (int i = vw; i < words; ++i) m_data.num()[i].m_value = 0;
opCleanThis();
UINFO(9, " opmoddiv-mod " << lhs << " " << rhs << " now=" << *this << endl);
return *this;
@ -2209,7 +2209,7 @@ V3Number& V3Number::opPow(const V3Number& lhs, const V3Number& rhs, bool lsign,
m_data.num()[0].m_value = 1;
V3Number power(&lhs, width());
power.opAssign(lhs);
for (int bit = 0; bit < rhs.width(); bit++) {
for (int bit = 0; bit < rhs.width(); ++bit) {
if (bit > 0) { // power = power*power
V3Number lastPower(&lhs, width());
lastPower.opAssign(power);
@ -2241,7 +2241,7 @@ V3Number& V3Number::opBufIf1(const V3Number& ens, const V3Number& if1s) {
NUM_ASSERT_OP_ARGS2(ens, if1s);
NUM_ASSERT_LOGIC_ARGS2(ens, if1s);
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (ens.bitIs1(bit)) {
setBit(bit, if1s.bitIs(bit));
} else {
@ -2273,7 +2273,7 @@ V3Number& V3Number::opAssignNonXZ(const V3Number& lhs, bool ignoreXZ) {
} else if (lhs.isDouble()) {
setDouble(lhs.toDouble());
} else {
for (int bit = 0; bit < this->width(); bit++) {
for (int bit = 0; bit < this->width(); ++bit) {
setBit(bit, ignoreXZ ? lhs.bitIs1(bit) : lhs.bitIs(bit));
}
}
@ -2302,7 +2302,7 @@ V3Number& V3Number::opExtendS(const V3Number& lhs, uint32_t lbits) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
setZero();
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
const char extendWith = lhs.bitIsExtend(bit, lbits);
setBit(bit, extendWith);
}
@ -2314,7 +2314,7 @@ V3Number& V3Number::opExtendXZ(const V3Number& lhs, uint32_t lbits) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
setZero();
for (int bit = 0; bit < width(); bit++) setBit(bit, lhs.bitIsExtend(bit, lbits));
for (int bit = 0; bit < width(); ++bit) setBit(bit, lhs.bitIsExtend(bit, lbits));
return *this;
}
@ -2347,7 +2347,7 @@ V3Number& V3Number::opSel(const V3Number& lhs, uint32_t msbval, uint32_t lsbval)
NUM_ASSERT_LOGIC_ARGS1(lhs);
setZero();
int ibit = lsbval;
for (int bit = 0; bit < width(); bit++) {
for (int bit = 0; bit < width(); ++bit) {
if (ibit >= 0 && ibit < lhs.width() && ibit <= static_cast<int>(msbval)) {
setBit(bit, lhs.bitIs(ibit));
} else {
@ -2368,13 +2368,13 @@ V3Number& V3Number::opSelInto(const V3Number& lhs, int lsbval, int width) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_LOGIC_ARGS1(lhs);
int ibit = 0;
for (int bit = lsbval; bit < lsbval + width; bit++) {
for (int bit = lsbval; bit < lsbval + width; ++bit) {
if (ibit >= 0 && ibit < lhs.width()) {
setBit(bit, lhs.bitIs(ibit));
} else {
setBitX0(bit);
}
ibit++;
++ibit;
}
return *this;
}
@ -2544,7 +2544,7 @@ V3Number& V3Number::opReplN(const V3Number& lhs, uint32_t rhsval) {
NUM_ASSERT_STRING_ARGS1(lhs);
string out;
out.reserve(lhs.toString().length() * rhsval);
for (unsigned times = 0; times < rhsval; times++) out += lhs.toString();
for (unsigned times = 0; times < rhsval; ++times) out += lhs.toString();
return setString(out);
}
V3Number& V3Number::opToLowerN(const V3Number& lhs) {

2
src/V3Number.h
View File

@ -628,7 +628,7 @@ public:
bool isFourState() const VL_MT_SAFE;
bool hasZ() const {
if (isString()) return false;
for (int i = 0; i < words(); i++) {
for (int i = 0; i < words(); ++i) {
const ValueAndX v = m_data.num()[i];
if ((~v.m_value) & v.m_valueX) return true;
}

2
src/V3Stats.h
View File

@ -46,7 +46,7 @@ public:
}
VDouble0 operator++(int) { // postfix
VDouble0 old = *this;
m_d++;
++m_d;
return old;
}
VDouble0& operator=(const double v) {