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

Remove VL_ULL as ULL now in MSVC & C++11

Browse Source
This commit is contained in:
Wilson Snyder 2020-05-28 20:32:07 -04:00
parent 3f66f846cd
commit 5089ac6119
15 changed files with 98 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
include/verilated.cpp
View File

@ -337,7 +337,7 @@ IData VL_RAND_RESET_I(int obits) VL_MT_SAFE {
} }
QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE { QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
if (Verilated::randReset() == 0) return 0; if (Verilated::randReset() == 0) return 0;
QData data = VL_ULL(~0); QData data = ~0ULL;
if (Verilated::randReset() != 1) { // if 2, randomize if (Verilated::randReset() != 1) { // if 2, randomize
data = VL_RANDOM_Q(obits); data = VL_RANDOM_Q(obits);
} }
@ -394,7 +394,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp,
if (vw == 1) { // Single divisor word breaks rest of algorithm if (vw == 1) { // Single divisor word breaks rest of algorithm
vluint64_t k = 0; vluint64_t k = 0;
for (int j = uw - 1; j >= 0; --j) { for (int j = uw - 1; j >= 0; --j) {
vluint64_t unw64 = ((k << VL_ULL(32)) + static_cast<vluint64_t>(lwp[j])); vluint64_t unw64 = ((k << 32ULL) + static_cast<vluint64_t>(lwp[j]));
owp[j] = unw64 / static_cast<vluint64_t>(rwp[0]); owp[j] = unw64 / static_cast<vluint64_t>(rwp[0]);
k = unw64 - static_cast<vluint64_t>(owp[j]) * static_cast<vluint64_t>(rwp[0]); k = unw64 - static_cast<vluint64_t>(owp[j]) * static_cast<vluint64_t>(rwp[0]);
} }
@ -436,26 +436,25 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp,
// Main loop // Main loop
for (int j = uw - vw; j >= 0; --j) { for (int j = uw - vw; j >= 0; --j) {
// Estimate // Estimate
vluint64_t unw64 = (static_cast<vluint64_t>(un[j + vw]) << VL_ULL(32) vluint64_t unw64 = (static_cast<vluint64_t>(un[j + vw]) << 32ULL
| static_cast<vluint64_t>(un[j + vw - 1])); | static_cast<vluint64_t>(un[j + vw - 1]));
vluint64_t qhat = unw64 / static_cast<vluint64_t>(vn[vw - 1]); vluint64_t qhat = unw64 / static_cast<vluint64_t>(vn[vw - 1]);
vluint64_t rhat = unw64 - qhat * static_cast<vluint64_t>(vn[vw - 1]); vluint64_t rhat = unw64 - qhat * static_cast<vluint64_t>(vn[vw - 1]);
again: again:
if (qhat >= VL_ULL(0x100000000) if (qhat >= 0x100000000ULL || ((qhat * vn[vw - 2]) > ((rhat << 32ULL) + un[j + vw - 2]))) {
|| ((qhat * vn[vw - 2]) > ((rhat << VL_ULL(32)) + un[j + vw - 2]))) {
qhat = qhat - 1; qhat = qhat - 1;
rhat = rhat + vn[vw - 1]; rhat = rhat + vn[vw - 1];
if (rhat < VL_ULL(0x100000000)) goto again; if (rhat < 0x100000000ULL) goto again;
} }
vlsint64_t t = 0; // Must be signed vlsint64_t t = 0; // Must be signed
vluint64_t k = 0; vluint64_t k = 0;
for (int i = 0; i < vw; ++i) { for (int i = 0; i < vw; ++i) {
vluint64_t p = qhat * vn[i]; // Multiply by estimate vluint64_t p = qhat * vn[i]; // Multiply by estimate
t = un[i + j] - k - (p & VL_ULL(0xFFFFFFFF)); // Subtract t = un[i + j] - k - (p & 0xFFFFFFFFULL); // Subtract
un[i + j] = t; un[i + j] = t;
k = (p >> VL_ULL(32)) - (t >> VL_ULL(32)); k = (p >> 32ULL) - (t >> 32ULL);
} }
t = un[j + vw] - k; t = un[j + vw] - k;
un[j + vw] = t; un[j + vw] = t;
@ -468,7 +467,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp,
for (int i = 0; i < vw; ++i) { for (int i = 0; i < vw; ++i) {
t = static_cast<vluint64_t>(un[i + j]) + static_cast<vluint64_t>(vn[i]) + k; t = static_cast<vluint64_t>(un[i + j]) + static_cast<vluint64_t>(vn[i]) + k;
un[i + j] = t; un[i + j] = t;
k = t >> VL_ULL(32); k = t >> 32ULL;
} }
un[j + vw] = un[j + vw] + k; un[j + vw] = un[j + vw] + k;
} }
@ -519,7 +518,7 @@ QData VL_POW_QQW(int, int, int rbits, QData lhs, WDataInP rwp) VL_MT_SAFE {
// Skip check for rhs == 0, as short-circuit doesn't save time // Skip check for rhs == 0, as short-circuit doesn't save time
if (VL_UNLIKELY(lhs == 0)) return 0; if (VL_UNLIKELY(lhs == 0)) return 0;
QData power = lhs; QData power = lhs;
QData out = VL_ULL(1); QData out = 1ULL;
for (int bit = 0; bit < rbits; ++bit) { for (int bit = 0; bit < rbits; ++bit) {
if (bit > 0) power = power * power; if (bit > 0) power = power * power;
if (VL_BITISSET_W(rwp, bit)) out *= power; if (VL_BITISSET_W(rwp, bit)) out *= power;
@ -1050,7 +1049,7 @@ IData _vl_vsscanf(FILE* fp, // If a fscanf
// Note LSBs are preserved if there's an overflow // Note LSBs are preserved if there's an overflow
const int obits = inIgnore ? 0 : va_arg(ap, int); const int obits = inIgnore ? 0 : va_arg(ap, int);
WData qowp[VL_WQ_WORDS_E]; WData qowp[VL_WQ_WORDS_E];
VL_SET_WQ(qowp, VL_ULL(0)); VL_SET_WQ(qowp, 0ULL);
WDataOutP owp = qowp; WDataOutP owp = qowp;
if (obits > VL_QUADSIZE) owp = va_arg(ap, WDataOutP); if (obits > VL_QUADSIZE) owp = va_arg(ap, WDataOutP);
for (int i = 0; i < VL_WORDS_I(obits); ++i) owp[i] = 0; for (int i = 0; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
@ -1815,7 +1814,7 @@ bool VlReadMem::get(QData& addrr, std::string& valuer) {
lastc = c; lastc = c;
} }
if (VL_UNLIKELY(m_end != ~VL_ULL(0) && m_addr <= m_end)) { if (VL_UNLIKELY(m_end != ~0ULL && m_addr <= m_end)) {
VL_FATAL_MT(m_filename.c_str(), m_linenum, "", VL_FATAL_MT(m_filename.c_str(), m_linenum, "",
"$readmem file ended before specified final address (IEEE 2017 21.4)"); "$readmem file ended before specified final address (IEEE 2017 21.4)");
} }
@ -1823,7 +1822,7 @@ bool VlReadMem::get(QData& addrr, std::string& valuer) {
return false; // EOF return false; // EOF
} }
void VlReadMem::setData(void* valuep, const std::string& rhs) { void VlReadMem::setData(void* valuep, const std::string& rhs) {
QData shift = m_hex ? VL_ULL(4) : VL_ULL(1); QData shift = m_hex ? 4ULL : 1ULL;
bool innum = false; bool innum = false;
// Shift value in // Shift value in
for (std::string::const_iterator it = rhs.begin(); it != rhs.end(); ++it) { for (std::string::const_iterator it = rhs.begin(); it != rhs.end(); ++it) {

67
include/verilated.h
View File

@ -707,7 +707,7 @@ extern const char* vl_mc_scan_plusargs(const char* prefixp); // PLIish
/// Return true if data[bit] set; not 0/1 return, but 0/non-zero return. /// Return true if data[bit] set; not 0/1 return, but 0/non-zero return.
#define VL_BITISSET_I(data, bit) ((data) & (VL_UL(1) << VL_BITBIT_I(bit))) #define VL_BITISSET_I(data, bit) ((data) & (VL_UL(1) << VL_BITBIT_I(bit)))
#define VL_BITISSET_Q(data, bit) ((data) & (VL_ULL(1) << VL_BITBIT_Q(bit))) #define VL_BITISSET_Q(data, bit) ((data) & (1ULL << VL_BITBIT_Q(bit)))
#define VL_BITISSET_E(data, bit) ((data) & (VL_EUL(1) << VL_BITBIT_E(bit))) #define VL_BITISSET_E(data, bit) ((data) & (VL_EUL(1) << VL_BITBIT_E(bit)))
#define VL_BITISSET_W(data, bit) ((data)[VL_BITWORD_E(bit)] & (VL_EUL(1) << VL_BITBIT_E(bit))) #define VL_BITISSET_W(data, bit) ((data)[VL_BITWORD_E(bit)] & (VL_EUL(1) << VL_BITBIT_E(bit)))
#define VL_BITISSETLIMIT_W(data, width, bit) (((bit) < (width)) && VL_BITISSET_W(data, bit)) #define VL_BITISSETLIMIT_W(data, width, bit) (((bit) < (width)) && VL_BITISSET_W(data, bit))
@ -730,7 +730,7 @@ extern const char* vl_mc_scan_plusargs(const char* prefixp); // PLIish
#define VL_SET_QW(lwp) \ #define VL_SET_QW(lwp) \
((static_cast<QData>((lwp)[0])) \ ((static_cast<QData>((lwp)[0])) \
| (static_cast<QData>((lwp)[1]) << (static_cast<QData>(VL_EDATASIZE)))) | (static_cast<QData>((lwp)[1]) << (static_cast<QData>(VL_EDATASIZE))))
#define _VL_SET_QII(ld, rd) ((static_cast<QData>(ld) << VL_ULL(32)) | static_cast<QData>(rd)) #define _VL_SET_QII(ld, rd) ((static_cast<QData>(ld) << 32ULL) | static_cast<QData>(rd))
/// Return FILE* from IData /// Return FILE* from IData
extern FILE* VL_CVT_I_FP(IData lhs) VL_MT_SAFE; extern FILE* VL_CVT_I_FP(IData lhs) VL_MT_SAFE;
@ -776,7 +776,7 @@ static inline IData VL_RTOI_I_D(double lhs) VL_PURE {
// Sign extend such that if MSB set, we get ffff_ffff, else 0s // Sign extend such that if MSB set, we get ffff_ffff, else 0s
// (Requires clean input) // (Requires clean input)
#define VL_SIGN_I(nbits, lhs) ((lhs) >> VL_BITBIT_I((nbits)-VL_UL(1))) #define VL_SIGN_I(nbits, lhs) ((lhs) >> VL_BITBIT_I((nbits)-VL_UL(1)))
#define VL_SIGN_Q(nbits, lhs) ((lhs) >> VL_BITBIT_Q((nbits)-VL_ULL(1))) #define VL_SIGN_Q(nbits, lhs) ((lhs) >> VL_BITBIT_Q((nbits)-1ULL))
#define VL_SIGN_E(nbits, lhs) ((lhs) >> VL_BITBIT_E((nbits)-VL_EUL(1))) #define VL_SIGN_E(nbits, lhs) ((lhs) >> VL_BITBIT_E((nbits)-VL_EUL(1)))
#define VL_SIGN_W(nbits, rwp) \ #define VL_SIGN_W(nbits, rwp) \
((rwp)[VL_BITWORD_E((nbits)-VL_EUL(1))] >> VL_BITBIT_E((nbits)-VL_EUL(1))) ((rwp)[VL_BITWORD_E((nbits)-VL_EUL(1))] >> VL_BITBIT_E((nbits)-VL_EUL(1)))
@ -788,7 +788,7 @@ static inline IData VL_EXTENDSIGN_I(int lbits, IData lhs) VL_PURE {
return (-((lhs) & (VL_UL(1) << (lbits - 1)))); return (-((lhs) & (VL_UL(1) << (lbits - 1))));
} }
static inline QData VL_EXTENDSIGN_Q(int lbits, QData lhs) VL_PURE { static inline QData VL_EXTENDSIGN_Q(int lbits, QData lhs) VL_PURE {
return (-((lhs) & (VL_ULL(1) << (lbits - 1)))); return (-((lhs) & (1ULL << (lbits - 1))));
} }
// Debugging prints // Debugging prints
@ -926,8 +926,7 @@ static inline void VL_ASSIGNBIT_II(int, int bit, IData& lhsr, IData rhs) VL_PURE
lhsr = ((lhsr & ~(VL_UL(1) << VL_BITBIT_I(bit))) | (rhs << VL_BITBIT_I(bit))); lhsr = ((lhsr & ~(VL_UL(1) << VL_BITBIT_I(bit))) | (rhs << VL_BITBIT_I(bit)));
} }
static inline void VL_ASSIGNBIT_QI(int, int bit, QData& lhsr, QData rhs) VL_PURE { static inline void VL_ASSIGNBIT_QI(int, int bit, QData& lhsr, QData rhs) VL_PURE {
lhsr = ((lhsr & ~(VL_ULL(1) << VL_BITBIT_Q(bit))) lhsr = ((lhsr & ~(1ULL << VL_BITBIT_Q(bit))) | (static_cast<QData>(rhs) << VL_BITBIT_Q(bit)));
| (static_cast<QData>(rhs) << VL_BITBIT_Q(bit)));
} }
static inline void VL_ASSIGNBIT_WI(int, int bit, WDataOutP owp, IData rhs) VL_MT_SAFE { static inline void VL_ASSIGNBIT_WI(int, int bit, WDataOutP owp, IData rhs) VL_MT_SAFE {
EData orig = owp[VL_BITWORD_E(bit)]; EData orig = owp[VL_BITWORD_E(bit)];
@ -945,7 +944,7 @@ static inline void VL_ASSIGNBIT_IO(int, int bit, IData& lhsr, IData) VL_PURE {
lhsr = (lhsr | (VL_UL(1) << VL_BITBIT_I(bit))); lhsr = (lhsr | (VL_UL(1) << VL_BITBIT_I(bit)));
} }
static inline void VL_ASSIGNBIT_QO(int, int bit, QData& lhsr, IData) VL_PURE { static inline void VL_ASSIGNBIT_QO(int, int bit, QData& lhsr, IData) VL_PURE {
lhsr = (lhsr | (VL_ULL(1) << VL_BITBIT_Q(bit))); lhsr = (lhsr | (1ULL << VL_BITBIT_Q(bit)));
} }
static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) VL_MT_SAFE { static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) VL_MT_SAFE {
EData orig = owp[VL_BITWORD_E(bit)]; EData orig = owp[VL_BITWORD_E(bit)];
@ -1287,7 +1286,7 @@ static inline IData VL_CLOG2_Q(QData lhs) VL_PURE {
if (VL_UNLIKELY(!lhs)) return 0; if (VL_UNLIKELY(!lhs)) return 0;
lhs--; lhs--;
int shifts = 0; int shifts = 0;
for (; lhs != 0; ++shifts) lhs = lhs >> VL_ULL(1); for (; lhs != 0; ++shifts) lhs = lhs >> 1ULL;
return shifts; return shifts;
} }
static inline IData VL_CLOG2_W(int words, WDataInP lwp) VL_MT_SAFE { static inline IData VL_CLOG2_W(int words, WDataInP lwp) VL_MT_SAFE {
@ -1485,8 +1484,8 @@ static inline WDataOutP VL_ADD_W(int words, WDataOutP owp, WDataInP lwp, WDataIn
QData carry = 0; QData carry = 0;
for (int i = 0; i < words; ++i) { for (int i = 0; i < words; ++i) {
carry = carry + static_cast<QData>(lwp[i]) + static_cast<QData>(rwp[i]); carry = carry + static_cast<QData>(lwp[i]) + static_cast<QData>(rwp[i]);
owp[i] = (carry & VL_ULL(0xffffffff)); owp[i] = (carry & 0xffffffffULL);
carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff); carry = (carry >> 32ULL) & 0xffffffffULL;
} }
// Last output word is dirty // Last output word is dirty
return owp; return owp;
@ -1498,8 +1497,8 @@ static inline WDataOutP VL_SUB_W(int words, WDataOutP owp, WDataInP lwp, WDataIn
carry = (carry + static_cast<QData>(lwp[i]) carry = (carry + static_cast<QData>(lwp[i])
+ static_cast<QData>(static_cast<IData>(~rwp[i]))); + static_cast<QData>(static_cast<IData>(~rwp[i])));
if (i == 0) ++carry; // Negation of rwp if (i == 0) ++carry; // Negation of rwp
owp[i] = (carry & VL_ULL(0xffffffff)); owp[i] = (carry & 0xffffffffULL);
carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff); carry = (carry >> 32ULL) & 0xffffffffULL;
} }
// Last output word is dirty // Last output word is dirty
return owp; return owp;
@ -1512,8 +1511,8 @@ static inline WDataOutP VL_MUL_W(int words, WDataOutP owp, WDataInP lwp, WDataIn
QData mul = static_cast<QData>(lwp[lword]) * static_cast<QData>(rwp[rword]); QData mul = static_cast<QData>(lwp[lword]) * static_cast<QData>(rwp[rword]);
for (int qword = lword + rword; qword < words; ++qword) { for (int qword = lword + rword; qword < words; ++qword) {
mul += static_cast<QData>(owp[qword]); mul += static_cast<QData>(owp[qword]);
owp[qword] = (mul & VL_ULL(0xffffffff)); owp[qword] = (mul & 0xffffffffULL);
mul = (mul >> VL_ULL(32)) & VL_ULL(0xffffffff); mul = (mul >> 32ULL) & 0xffffffffULL;
} }
} }
} }
@ -1561,8 +1560,8 @@ static inline WDataOutP VL_MULS_WWW(int, int lbits, int, WDataOutP owp, WDataInP
for (int i = 0; i < words; ++i) { for (int i = 0; i < words; ++i) {
carry = carry + static_cast<QData>(static_cast<IData>(~owp[i])); carry = carry + static_cast<QData>(static_cast<IData>(~owp[i]));
if (i == 0) ++carry; // Negation of temp2 if (i == 0) ++carry; // Negation of temp2
owp[i] = (carry & VL_ULL(0xffffffff)); owp[i] = (carry & 0xffffffffULL);
carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff); carry = (carry >> 32ULL) & 0xffffffffULL;
} }
// Not needed: owp[words-1] |= 1<<VL_BITBIT_E(lbits-1); // Set sign bit // Not needed: owp[words-1] |= 1<<VL_BITBIT_E(lbits-1); // Set sign bit
} }
@ -1653,7 +1652,7 @@ static inline IData VL_POW_III(int, int, int rbits, IData lhs, IData rhs) VL_PUR
IData out = 1; IData out = 1;
for (int i = 0; i < rbits; ++i) { for (int i = 0; i < rbits; ++i) {
if (i > 0) power = power * power; if (i > 0) power = power * power;
if (rhs & (VL_ULL(1) << i)) out *= power; if (rhs & (1ULL << i)) out *= power;
} }
return out; return out;
} }
@ -1661,10 +1660,10 @@ static inline QData VL_POW_QQQ(int, int, int rbits, QData lhs, QData rhs) VL_PUR
if (VL_UNLIKELY(rhs == 0)) return 1; if (VL_UNLIKELY(rhs == 0)) return 1;
if (VL_UNLIKELY(lhs == 0)) return 0; if (VL_UNLIKELY(lhs == 0)) return 0;
QData power = lhs; QData power = lhs;
QData out = VL_ULL(1); QData out = 1ULL;
for (int i = 0; i < rbits; ++i) { for (int i = 0; i < rbits; ++i) {
if (i > 0) power = power * power; if (i > 0) power = power * power;
if (rhs & (VL_ULL(1) << i)) out *= power; if (rhs & (1ULL << i)) out *= power;
} }
return out; return out;
} }
@ -1922,24 +1921,24 @@ static inline QData VL_STREAML_FAST_QQI(int, int lbits, int, QData ld, IData rd_
vluint32_t lbitsFloor = lbits & ~VL_MASK_I(rd_log2); vluint32_t lbitsFloor = lbits & ~VL_MASK_I(rd_log2);
vluint32_t lbitsRem = lbits - lbitsFloor; vluint32_t lbitsRem = lbits - lbitsFloor;
QData msbMask = VL_MASK_Q(lbitsRem) << lbitsFloor; QData msbMask = VL_MASK_Q(lbitsRem) << lbitsFloor;
ret = (ret & ~msbMask) | ((ret & msbMask) << ((VL_ULL(1) << rd_log2) - lbitsRem)); ret = (ret & ~msbMask) | ((ret & msbMask) << ((1ULL << rd_log2) - lbitsRem));
} }
switch (rd_log2) { switch (rd_log2) {
case 0: case 0:
ret = (((ret >> 1) & VL_ULL(0x5555555555555555)) ret = (((ret >> 1) & 0x5555555555555555ULL)
| ((ret & VL_ULL(0x5555555555555555)) << 1)); // FALLTHRU | ((ret & 0x5555555555555555ULL) << 1)); // FALLTHRU
case 1: case 1:
ret = (((ret >> 2) & VL_ULL(0x3333333333333333)) ret = (((ret >> 2) & 0x3333333333333333ULL)
| ((ret & VL_ULL(0x3333333333333333)) << 2)); // FALLTHRU | ((ret & 0x3333333333333333ULL) << 2)); // FALLTHRU
case 2: case 2:
ret = (((ret >> 4) & VL_ULL(0x0f0f0f0f0f0f0f0f)) ret = (((ret >> 4) & 0x0f0f0f0f0f0f0f0fULL)
| ((ret & VL_ULL(0x0f0f0f0f0f0f0f0f)) << 4)); // FALLTHRU | ((ret & 0x0f0f0f0f0f0f0f0fULL) << 4)); // FALLTHRU
case 3: case 3:
ret = (((ret >> 8) & VL_ULL(0x00ff00ff00ff00ff)) ret = (((ret >> 8) & 0x00ff00ff00ff00ffULL)
| ((ret & VL_ULL(0x00ff00ff00ff00ff)) << 8)); // FALLTHRU | ((ret & 0x00ff00ff00ff00ffULL) << 8)); // FALLTHRU
case 4: case 4:
ret = (((ret >> 16) & VL_ULL(0x0000ffff0000ffff)) ret = (((ret >> 16) & 0x0000ffff0000ffffULL)
| ((ret & VL_ULL(0x0000ffff0000ffff)) << 16)); // FALLTHRU | ((ret & 0x0000ffff0000ffffULL) << 16)); // FALLTHRU
case 5: ret = ((ret >> 32) | (ret << 32)); case 5: ret = ((ret >> 32) | (ret << 32));
} }
return ret >> (VL_QUADSIZE - lbits); return ret >> (VL_QUADSIZE - lbits);
@ -2390,8 +2389,8 @@ static inline QData VL_RTOIROUND_Q_D(int, double lhs) VL_PURE {
lhs = VL_ROUND(lhs); lhs = VL_ROUND(lhs);
if (lhs == 0.0) return 0; if (lhs == 0.0) return 0;
QData q = VL_CVT_Q_D(lhs); QData q = VL_CVT_Q_D(lhs);
int lsb = static_cast<int>((q >> VL_ULL(52)) & VL_MASK_Q(11)) - 1023 - 52; int lsb = static_cast<int>((q >> 52ULL) & VL_MASK_Q(11)) - 1023 - 52;
vluint64_t mantissa = (q & VL_MASK_Q(52)) | (VL_ULL(1) << 52); vluint64_t mantissa = (q & VL_MASK_Q(52)) | (1ULL << 52);
vluint64_t out = 0; vluint64_t out = 0;
if (lsb < 0) { if (lsb < 0) {
out = mantissa >> -lsb; out = mantissa >> -lsb;
@ -2411,8 +2410,8 @@ static inline WDataOutP VL_RTOIROUND_W_D(int obits, WDataOutP owp, double lhs) V
VL_ZERO_W(obits, owp); VL_ZERO_W(obits, owp);
if (lhs == 0.0) return owp; if (lhs == 0.0) return owp;
QData q = VL_CVT_Q_D(lhs); QData q = VL_CVT_Q_D(lhs);
int lsb = static_cast<int>((q >> VL_ULL(52)) & VL_MASK_Q(11)) - 1023 - 52; int lsb = static_cast<int>((q >> 52ULL) & VL_MASK_Q(11)) - 1023 - 52;
vluint64_t mantissa = (q & VL_MASK_Q(52)) | (VL_ULL(1) << 52); vluint64_t mantissa = (q & VL_MASK_Q(52)) | (1ULL << 52);
if (lsb < 0) { if (lsb < 0) {
VL_SET_WQ(owp, mantissa >> -lsb); VL_SET_WQ(owp, mantissa >> -lsb);
} else if (lsb < obits) { } else if (lsb < obits) {

2
include/verilated_dpi.cpp
View File

@ -416,7 +416,7 @@ static svBit _vl_svGetBitArrElem(const svOpenArrayHandle s, int nargs, int indx1
case VLVT_UINT16: return (*(reinterpret_cast<SData*>(datap)) >> lsb) & 1; case VLVT_UINT16: return (*(reinterpret_cast<SData*>(datap)) >> lsb) & 1;
case VLVT_UINT32: return (*(reinterpret_cast<IData*>(datap)) >> lsb) & 1; case VLVT_UINT32: return (*(reinterpret_cast<IData*>(datap)) >> lsb) & 1;
case VLVT_UINT64: case VLVT_UINT64:
return (*(reinterpret_cast<QData*>(datap)) >> static_cast<QData>(lsb)) & VL_ULL(1); return (*(reinterpret_cast<QData*>(datap)) >> static_cast<QData>(lsb)) & 1ULL;
case VLVT_WDATA: { case VLVT_WDATA: {
WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap)); WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
return VL_BITRSHIFT_W(wdatap, lsb) & 1; return VL_BITRSHIFT_W(wdatap, lsb) & 1;

10
include/verilated_unordered_set_map.h
View File

@ -225,8 +225,7 @@ public:
return end(); return end();
} }
const_iterator end() const { const_iterator end() const {
return iterator(VL_ULL(0xFFFFFFFFFFFFFFFF), const_cast<Bucket&>(m_emptyBucket).begin(), return iterator(0xFFFFFFFFFFFFFFFFULL, const_cast<Bucket&>(m_emptyBucket).begin(), this);
this);
} }
bool empty() const { return m_numElements == 0; } bool empty() const { return m_numElements == 0; }
@ -249,8 +248,7 @@ public:
// function further. This permits the use of very fast client // function further. This permits the use of very fast client
// hash funcs (like just returning the int or pointer value as // hash funcs (like just returning the int or pointer value as
// is!) and tolerates crappy client hash functions pretty well. // is!) and tolerates crappy client hash functions pretty well.
size_t mult size_t mult = hashVal * ((sizeof(size_t) == 8) ? 11400714819323198485ULL : 2654435769lu);
= hashVal * ((sizeof(size_t) == 8) ? VL_ULL(11400714819323198485) : 2654435769lu);
size_t result = (mult >> (((sizeof(size_t) == 8) ? 64 : 32) - log2Buckets)); size_t result = (mult >> (((sizeof(size_t) == 8) ? 64 : 32) - log2Buckets));
return result; return result;
} }
@ -339,7 +337,7 @@ public:
} }
private: private:
size_t numBuckets() const { return (VL_ULL(1) << m_log2Buckets); } size_t numBuckets() const { return (1ULL << m_log2Buckets); }
Bucket* getBucket(size_t idx) { Bucket* getBucket(size_t idx) {
initBuckets(); initBuckets();
@ -372,7 +370,7 @@ private:
new_log2Buckets = m_log2Buckets - 2; new_log2Buckets = m_log2Buckets - 2;
} }
size_t new_num_buckets = VL_ULL(1) << new_log2Buckets; size_t new_num_buckets = 1ULL << new_log2Buckets;
Bucket* new_bucketsp = new Bucket[new_num_buckets]; Bucket* new_bucketsp = new Bucket[new_num_buckets];
for (size_t i = 0; i < numBuckets(); i++) { for (size_t i = 0; i < numBuckets(); i++) {

15
include/verilated_vcd_c.cpp
View File

@ -732,7 +732,7 @@ void VerilatedVcd::fullQuad(vluint32_t code, const vluint64_t newval, int bits)
(*(reinterpret_cast<vluint64_t*>(oldp(code)))) = newval; (*(reinterpret_cast<vluint64_t*>(oldp(code)))) = newval;
*m_writep++ = 'b'; *m_writep++ = 'b';
for (int bit = bits - 1; bit >= 0; --bit) { for (int bit = bits - 1; bit >= 0; --bit) {
*m_writep++ = ((newval & (VL_ULL(1) << bit)) ? '1' : '0'); *m_writep++ = ((newval & (1ULL << bit)) ? '1' : '0');
} }
*m_writep++ = ' '; *m_writep++ = ' ';
m_writep = writeCode(m_writep, code); m_writep = writeCode(m_writep, code);
@ -754,7 +754,7 @@ void VerilatedVcd::fullArray(vluint32_t code, const vluint64_t* newval, int bits
for (int word = 0; word < (((bits - 1) / 64) + 1); ++word) { oldp(code)[word] = newval[word]; } for (int word = 0; word < (((bits - 1) / 64) + 1); ++word) { oldp(code)[word] = newval[word]; }
*m_writep++ = 'b'; *m_writep++ = 'b';
for (int bit = bits - 1; bit >= 0; --bit) { for (int bit = bits - 1; bit >= 0; --bit) {
*m_writep++ = ((newval[(bit / 64)] & (VL_ULL(1) << (bit & 0x3f))) ? '1' : '0'); *m_writep++ = ((newval[(bit / 64)] & (1ULL << (bit & 0x3f))) ? '1' : '0');
} }
*m_writep++ = ' '; *m_writep++ = ' ';
m_writep = writeCode(m_writep, code); m_writep = writeCode(m_writep, code);
@ -788,8 +788,7 @@ void VerilatedVcd::fullTriQuad(vluint32_t code, const vluint64_t newval, const v
(*(reinterpret_cast<vluint64_t*>(oldp(code + 1)))) = newtri; (*(reinterpret_cast<vluint64_t*>(oldp(code + 1)))) = newtri;
*m_writep++ = 'b'; *m_writep++ = 'b';
for (int bit = bits - 1; bit >= 0; --bit) { for (int bit = bits - 1; bit >= 0; --bit) {
*m_writep++ *m_writep++ = "01zz"[((newval >> bit) & 1ULL) | (((newtri >> bit) & 1ULL) << 1ULL)];
= "01zz"[((newval >> bit) & VL_ULL(1)) | (((newtri >> bit) & VL_ULL(1)) << VL_ULL(1))];
} }
*m_writep++ = ' '; *m_writep++ = ' ';
m_writep = writeCode(m_writep, code); m_writep = writeCode(m_writep, code);
@ -935,8 +934,8 @@ void vcdTestMain(const char* filenamep) {
quad96[1] = 0; quad96[0] = ~0; quad96[1] = 0; quad96[0] = ~0;
doub = -1.66e13; doub = -1.66e13;
flo = 0.123f; flo = 0.123f;
tquad = VL_ULL(0x00ff00ff00ff00ff); tquad = 0x00ff00ff00ff00ffULL;
tquad__tri = VL_ULL(0x0000fffff0000ffff); tquad__tri = 0x0000fffff0000ffffULL;
vcdp->dump(++timestamp); vcdp->dump(++timestamp);
ch = 2; ch = 2;
tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1; tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1;
@ -944,8 +943,8 @@ void vcdTestMain(const char* filenamep) {
vcdp->dump(++timestamp); vcdp->dump(++timestamp);
vcdp->dump(++timestamp); vcdp->dump(++timestamp);
# ifdef VERILATED_VCD_TEST_64BIT # ifdef VERILATED_VCD_TEST_64BIT
vluint64_t bytesPerDump = VL_ULL(15); vluint64_t bytesPerDump = 15ULL;
for (vluint64_t i = 0; i < ((VL_ULL(1) << 32) / bytesPerDump); i++) { for (vluint64_t i = 0; i < ((1ULL << 32) / bytesPerDump); i++) {
v1 = i; v1 = i;
vcdp->dump(++timestamp); vcdp->dump(++timestamp);
} }

4
include/verilated_vcd_c.h
View File

@ -246,7 +246,7 @@ public:
inline void chgQuad(vluint32_t code, const vluint64_t newval, int bits) { inline void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
vluint64_t diff = (*(reinterpret_cast<vluint64_t*>(oldp(code)))) ^ newval; vluint64_t diff = (*(reinterpret_cast<vluint64_t*>(oldp(code)))) ^ newval;
if (VL_UNLIKELY(diff)) { if (VL_UNLIKELY(diff)) {
if (VL_UNLIKELY(bits == 64 || (diff & ((VL_ULL(1) << bits) - 1)))) { if (VL_UNLIKELY(bits == 64 || (diff & ((1ULL << bits) - 1)))) {
fullQuad(code, newval, bits); fullQuad(code, newval, bits);
} }
} }
@ -292,7 +292,7 @@ public:
vluint64_t diff = (((*(reinterpret_cast<vluint64_t*>(oldp(code)))) ^ newval) vluint64_t diff = (((*(reinterpret_cast<vluint64_t*>(oldp(code)))) ^ newval)
| ((*(reinterpret_cast<vluint64_t*>(oldp(code + 1)))) ^ newtri)); | ((*(reinterpret_cast<vluint64_t*>(oldp(code + 1)))) ^ newtri));
if (VL_UNLIKELY(diff)) { if (VL_UNLIKELY(diff)) {
if (VL_UNLIKELY(bits == 64 || (diff & ((VL_ULL(1) << bits) - 1)))) { if (VL_UNLIKELY(bits == 64 || (diff & ((1ULL << bits) - 1)))) {
fullTriQuad(code, newval, newtri, bits); fullTriQuad(code, newval, newtri, bits);
} }
} }

4
include/verilated_vpi.cpp
View File

@ -450,7 +450,7 @@ public:
static QData cbNextDeadline() { static QData cbNextDeadline() {
VpioTimedCbs::const_iterator it = s_s.m_timedCbs.begin(); VpioTimedCbs::const_iterator it = s_s.m_timedCbs.begin();
if (VL_LIKELY(it != s_s.m_timedCbs.end())) return it->first; if (VL_LIKELY(it != s_s.m_timedCbs.end())) return it->first;
return ~VL_ULL(0); // maxquad return ~0ULL; // maxquad
} }
static bool callCbs(vluint32_t reason) VL_MT_UNSAFE_ONE { static bool callCbs(vluint32_t reason) VL_MT_UNSAFE_ONE {
VpioCbList& cbObjList = s_s.m_cbObjLists[reason]; VpioCbList& cbObjList = s_s.m_cbObjLists[reason];
@ -1361,7 +1361,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
} }
case VLVT_UINT64: { case VLVT_UINT64: {
QData data = *(reinterpret_cast<QData*>(vop->varDatap())); QData data = *(reinterpret_cast<QData*>(vop->varDatap()));
out[1].aval = static_cast<IData>(data >> VL_ULL(32)); out[1].aval = static_cast<IData>(data >> 32ULL);
out[1].bval = 0; out[1].bval = 0;
out[0].aval = static_cast<IData>(data); out[0].aval = static_cast<IData>(data);
out[0].bval = 0; out[0].bval = 0;

11
include/verilatedos.h
View File

@ -144,14 +144,7 @@
#define VL_MT_UNSAFE_ONE ///< Comment tag that function is not threadsafe when VL_THREADED, #define VL_MT_UNSAFE_ONE ///< Comment tag that function is not threadsafe when VL_THREADED,
///< protected to make sure single-caller ///< protected to make sure single-caller
#ifdef _MSC_VER #define VL_ULL(c) (c##ULL) ///< Add appropriate suffix to 64-bit constant (deprecated)
# define VL_ULL(c) (c##ULL) ///< Add appropriate suffix to 64-bit constant
// Was "(c##ui64)". C++11 has standardized on ULL, and MSVC now supports this.
// We propose to no longer require using this macro no sooner than June 2020.
// File an issue ASAP if this breaks anything.
#else
# define VL_ULL(c) (c##ULL) ///< Add appropriate suffix to 64-bit constant
#endif
// This is not necessarily the same as #UL, depending on what the IData typedef is. // This is not necessarily the same as #UL, depending on what the IData typedef is.
#define VL_UL(c) (static_cast<IData>(c##UL)) ///< Add appropriate suffix to 32-bit constant #define VL_UL(c) (static_cast<IData>(c##UL)) ///< Add appropriate suffix to 32-bit constant
@ -401,7 +394,7 @@ typedef unsigned long long vluint64_t; ///< 64-bit unsigned type
#define VL_MASK_I(nbits) (((nbits) & VL_SIZEBITS_I) ? ((1U << ((nbits) & VL_SIZEBITS_I)) - 1) : ~0) #define VL_MASK_I(nbits) (((nbits) & VL_SIZEBITS_I) ? ((1U << ((nbits) & VL_SIZEBITS_I)) - 1) : ~0)
/// Mask for quads with 1's where relevant bits are (0=all bits) /// Mask for quads with 1's where relevant bits are (0=all bits)
#define VL_MASK_Q(nbits) \ #define VL_MASK_Q(nbits) \
(((nbits) & VL_SIZEBITS_Q) ? ((VL_ULL(1) << ((nbits) & VL_SIZEBITS_Q)) - VL_ULL(1)) : VL_ULL(~0)) (((nbits) & VL_SIZEBITS_Q) ? ((1ULL << ((nbits) & VL_SIZEBITS_Q)) - 1ULL) : ~0ULL)
/// Mask for EData with 1's where relevant bits are (0=all bits) /// Mask for EData with 1's where relevant bits are (0=all bits)
#define VL_MASK_E(nbits) VL_MASK_I(nbits) #define VL_MASK_E(nbits) VL_MASK_I(nbits)
#define VL_EUL(n) VL_UL(n) ///< Make constant number EData sized #define VL_EUL(n) VL_UL(n) ///< Make constant number EData sized

12
src/V3AstNodes.h
View File

@ -7253,8 +7253,7 @@ class AstPreAdd : public AstNodeTriop {
// Children: thsp: tree with AstVarRef LValue that is stored after operation // Children: thsp: tree with AstVarRef LValue that is stored after operation
public: public:
AstPreAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) AstPreAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
: ASTGEN_SUPER(fl, lhsp, rhsp, thsp) { : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {}
}
ASTNODE_NODE_FUNCS(PreAdd) ASTNODE_NODE_FUNCS(PreAdd)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
const V3Number& ths) { const V3Number& ths) {
@ -7279,8 +7278,7 @@ class AstPreSub : public AstNodeTriop {
// Children: thsp: tree with AstVarRef LValue that is stored after operation // Children: thsp: tree with AstVarRef LValue that is stored after operation
public: public:
AstPreSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) AstPreSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
: ASTGEN_SUPER(fl, lhsp, rhsp, thsp) { : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {}
}
ASTNODE_NODE_FUNCS(PreSub) ASTNODE_NODE_FUNCS(PreSub)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
const V3Number& ths) { const V3Number& ths) {
@ -7305,8 +7303,7 @@ class AstPostAdd : public AstNodeTriop {
// Children: thsp: tree with AstVarRef LValue that is stored after operation // Children: thsp: tree with AstVarRef LValue that is stored after operation
public: public:
AstPostAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) AstPostAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
: ASTGEN_SUPER(fl, lhsp, rhsp, thsp) { : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {}
}
ASTNODE_NODE_FUNCS(PostAdd) ASTNODE_NODE_FUNCS(PostAdd)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
const V3Number& ths) { const V3Number& ths) {
@ -7331,8 +7328,7 @@ class AstPostSub : public AstNodeTriop {
// Children: thsp: tree with AstVarRef LValue that is stored after operation // Children: thsp: tree with AstVarRef LValue that is stored after operation
public: public:
AstPostSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) AstPostSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
: ASTGEN_SUPER(fl, lhsp, rhsp, thsp) { : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {}
}
ASTNODE_NODE_FUNCS(PostSub) ASTNODE_NODE_FUNCS(PostSub)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
const V3Number& ths) { const V3Number& ths) {

8
src/V3EmitC.cpp
View File

@ -585,7 +585,7 @@ public:
if (nodep->msbp()) { if (nodep->msbp()) {
iterateAndNextNull(nodep->msbp()); iterateAndNextNull(nodep->msbp());
} else { } else {
puts("~VL_ULL(0)"); puts("~0ULL");
} }
puts(");\n"); puts(");\n");
} }
@ -1137,9 +1137,9 @@ public:
} else if (nodep->isQuad()) { } else if (nodep->isQuad()) {
vluint64_t num = nodep->toUQuad(); vluint64_t num = nodep->toUQuad();
if (num < 10) { if (num < 10) {
ofp()->printf("VL_ULL(%" VL_PRI64 "u)", num); ofp()->printf("%" VL_PRI64 "uULL", num);
} else { } else {
ofp()->printf("VL_ULL(0x%" VL_PRI64 "x)", num); ofp()->printf("0x%" VL_PRI64 "xULL", num);
} }
} else { } else {
uint32_t num = nodep->toUInt(); uint32_t num = nodep->toUInt();
@ -2440,7 +2440,7 @@ void EmitCImp::emitSavableImp(AstNodeModule* modp) {
hash.insert(varp->dtypep()->width()); hash.insert(varp->dtypep()->width());
} }
} }
ofp()->printf("vluint64_t __Vcheckval = VL_ULL(0x%" VL_PRI64 "x);\n", ofp()->printf("vluint64_t __Vcheckval = 0x%" VL_PRI64 "xULL;\n",
static_cast<vluint64_t>(hash.digestUInt64())); static_cast<vluint64_t>(hash.digestUInt64()));
if (de) { if (de) {
puts("os.readAssert(__Vcheckval);\n"); puts("os.readAssert(__Vcheckval);\n");

35
src/V3Number.cpp
View File

@ -364,7 +364,7 @@ void V3Number::setNames(AstNode* nodep) {
int V3Number::log2b(uint32_t num) { int V3Number::log2b(uint32_t num) {
// See also opCLog2 // See also opCLog2
for (int bit = 31; bit > 0; bit--) { for (int bit = 31; bit > 0; bit--) {
if (num & (VL_ULL(1) << bit)) return bit; if (num & (1ULL << bit)) return bit;
} }
return 0; return 0;
} }
@ -378,8 +378,8 @@ V3Number& V3Number::setZero() {
} }
V3Number& V3Number::setQuad(vluint64_t value) { V3Number& V3Number::setQuad(vluint64_t value) {
for (int i = 0; i < words(); i++) m_value[i] = m_valueX[i] = 0; for (int i = 0; i < words(); i++) m_value[i] = m_valueX[i] = 0;
m_value[0] = value & VL_ULL(0xffffffff); m_value[0] = value & 0xffffffffULL;
m_value[1] = (value >> VL_ULL(32)) & VL_ULL(0xffffffff); m_value[1] = (value >> 32ULL) & 0xffffffffULL;
opCleanThis(); opCleanThis();
return *this; return *this;
} }
@ -851,14 +851,14 @@ vluint64_t V3Number::toUQuad() const {
} }
} }
if (width() <= 32) return (static_cast<vluint64_t>(toUInt())); if (width() <= 32) return (static_cast<vluint64_t>(toUInt()));
return ((static_cast<vluint64_t>(m_value[1]) << VL_ULL(32)) return ((static_cast<vluint64_t>(m_value[1]) << 32ULL)
| (static_cast<vluint64_t>(m_value[0]))); | (static_cast<vluint64_t>(m_value[0])));
} }
vlsint64_t V3Number::toSQuad() const { vlsint64_t V3Number::toSQuad() const {
if (isDouble()) return static_cast<vlsint64_t>(toDouble()); if (isDouble()) return static_cast<vlsint64_t>(toDouble());
vluint64_t v = toUQuad(); vluint64_t v = toUQuad();
vluint64_t signExtend = (-(v & (VL_ULL(1) << (width() - 1)))); vluint64_t signExtend = (-(v & (1ULL << (width() - 1))));
vluint64_t extended = v | signExtend; vluint64_t extended = v | signExtend;
return static_cast<vlsint64_t>(extended); return static_cast<vlsint64_t>(extended);
} }
@ -1837,8 +1837,8 @@ V3Number& V3Number::opMul(const V3Number& lhs, const V3Number& rhs) {
* static_cast<vluint64_t>(rhs.m_value[rword]); * static_cast<vluint64_t>(rhs.m_value[rword]);
for (int qword = lword + rword; qword < this->words(); qword++) { for (int qword = lword + rword; qword < this->words(); qword++) {
mul += static_cast<vluint64_t>(m_value[qword]); mul += static_cast<vluint64_t>(m_value[qword]);
m_value[qword] = (mul & VL_ULL(0xffffffff)); m_value[qword] = (mul & 0xffffffffULL);
mul = (mul >> VL_ULL(32)) & VL_ULL(0xffffffff); mul = (mul >> 32ULL) & 0xffffffffULL;
} }
} }
} }
@ -1953,7 +1953,7 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
if (vw == 1) { // Single divisor word breaks rest of algorithm if (vw == 1) { // Single divisor word breaks rest of algorithm
vluint64_t k = 0; vluint64_t k = 0;
for (int j = uw - 1; j >= 0; j--) { for (int j = uw - 1; j >= 0; j--) {
vluint64_t unw64 = ((k << VL_ULL(32)) + static_cast<vluint64_t>(lhs.m_value[j])); vluint64_t unw64 = ((k << 32ULL) + static_cast<vluint64_t>(lhs.m_value[j]));
m_value[j] = unw64 / static_cast<vluint64_t>(rhs.m_value[0]); m_value[j] = unw64 / static_cast<vluint64_t>(rhs.m_value[0]);
k = unw64 k = unw64
- (static_cast<vluint64_t>(m_value[j]) * static_cast<vluint64_t>(rhs.m_value[0])); - (static_cast<vluint64_t>(m_value[j]) * static_cast<vluint64_t>(rhs.m_value[0]));
@ -2003,26 +2003,25 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
// Main loop // Main loop
for (int j = uw - vw; j >= 0; j--) { for (int j = uw - vw; j >= 0; j--) {
// Estimate // Estimate
vluint64_t unw64 = (static_cast<vluint64_t>(un[j + vw]) << VL_ULL(32) vluint64_t unw64 = (static_cast<vluint64_t>(un[j + vw]) << 32ULL
| static_cast<vluint64_t>(un[j + vw - 1])); | static_cast<vluint64_t>(un[j + vw - 1]));
vluint64_t qhat = unw64 / static_cast<vluint64_t>(vn[vw - 1]); vluint64_t qhat = unw64 / static_cast<vluint64_t>(vn[vw - 1]);
vluint64_t rhat = unw64 - qhat * static_cast<vluint64_t>(vn[vw - 1]); vluint64_t rhat = unw64 - qhat * static_cast<vluint64_t>(vn[vw - 1]);
again: again:
if (qhat >= VL_ULL(0x100000000) if (qhat >= 0x100000000ULL || ((qhat * vn[vw - 2]) > ((rhat << 32ULL) + un[j + vw - 2]))) {
|| ((qhat * vn[vw - 2]) > ((rhat << VL_ULL(32)) + un[j + vw - 2]))) {
qhat = qhat - 1; qhat = qhat - 1;
rhat = rhat + vn[vw - 1]; rhat = rhat + vn[vw - 1];
if (rhat < VL_ULL(0x100000000)) goto again; if (rhat < 0x100000000ULL) goto again;
} }
vlsint64_t t = 0; // Must be signed vlsint64_t t = 0; // Must be signed
vluint64_t k = 0; vluint64_t k = 0;
for (int i = 0; i < vw; i++) { for (int i = 0; i < vw; i++) {
vluint64_t p = qhat * vn[i]; // Multiply by estimate vluint64_t p = qhat * vn[i]; // Multiply by estimate
t = un[i + j] - k - (p & VL_ULL(0xFFFFFFFF)); // Subtract t = un[i + j] - k - (p & 0xFFFFFFFFULL); // Subtract
un[i + j] = t; un[i + j] = t;
k = (p >> VL_ULL(32)) - (t >> VL_ULL(32)); k = (p >> 32ULL) - (t >> 32ULL);
} }
t = un[j + vw] - k; t = un[j + vw] - k;
un[j + vw] = t; un[j + vw] = t;
@ -2035,7 +2034,7 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
for (int i = 0; i < vw; i++) { for (int i = 0; i < vw; i++) {
t = static_cast<vluint64_t>(un[i + j]) + static_cast<vluint64_t>(vn[i]) + k; t = static_cast<vluint64_t>(un[i + j]) + static_cast<vluint64_t>(vn[i]) + k;
un[i + j] = t; un[i + j] = t;
k = t >> VL_ULL(32); k = t >> 32ULL;
} }
un[j + vw] = un[j + vw] + k; un[j + vw] = un[j + vw] + k;
} }
@ -2287,14 +2286,14 @@ V3Number& V3Number::opRToIRoundS(const V3Number& lhs) {
u.d = v; u.d = v;
if (u.d == 0.0) {} if (u.d == 0.0) {}
int exp = static_cast<int>((u.q >> VL_ULL(52)) & VL_MASK_Q(11)) - 1023; int exp = static_cast<int>((u.q >> 52ULL) & VL_MASK_Q(11)) - 1023;
int lsb = exp - 52; int lsb = exp - 52;
vluint64_t mantissa = (u.q & VL_MASK_Q(52)) | (VL_ULL(1) << 52); vluint64_t mantissa = (u.q & VL_MASK_Q(52)) | (1ULL << 52);
if (v != 0) { if (v != 0) {
// IEEE format: [63]=sign [62:52]=exp+1023 [51:0]=mantissa // IEEE format: [63]=sign [62:52]=exp+1023 [51:0]=mantissa
// This does not need to support subnormals as they are sub-integral // This does not need to support subnormals as they are sub-integral
for (int bit = 0; bit <= 52; ++bit) { for (int bit = 0; bit <= 52; ++bit) {
if (mantissa & (VL_ULL(1) << bit)) { if (mantissa & (1ULL << bit)) {
int outbit = bit + lsb; int outbit = bit + lsb;
if (outbit >= 0) setBit(outbit, 1); if (outbit >= 0) setBit(outbit, 1);
} }

2
src/V3Partition.cpp
View File

@ -330,7 +330,7 @@ private:
} }
void go() { void go() {
// Generate a pseudo-random graph // Generate a pseudo-random graph
vluint64_t rngState[2] = {VL_ULL(0x12345678), VL_ULL(0x9abcdef0)}; vluint64_t rngState[2] = {0x12345678ULL, 0x9abcdef0ULL};
// Create 50 vertices // Create 50 vertices
for (unsigned i = 0; i < 50; ++i) m_vx[i] = new V3GraphVertex(&m_graph); for (unsigned i = 0; i < 50; ++i) m_vx[i] = new V3GraphVertex(&m_graph);
// Create 250 edges at random. Edges must go from // Create 250 edges at random. Edges must go from

2
src/V3Width.cpp
View File

@ -2206,7 +2206,7 @@ private:
} }
} }
int selwidth = V3Number::log2b(msbdim) + 1; // Width to address a bit int selwidth = V3Number::log2b(msbdim) + 1; // Width to address a bit
AstVar* varp = enumVarp(adtypep, attrType, (VL_ULL(1) << selwidth) - 1); AstVar* varp = enumVarp(adtypep, attrType, (1ULL << selwidth) - 1);
AstVarRef* varrefp = new AstVarRef(nodep->fileline(), varp, false); AstVarRef* varrefp = new AstVarRef(nodep->fileline(), varp, false);
varrefp->packagep(v3Global.rootp()->dollarUnitPkgAddp()); varrefp->packagep(v3Global.rootp()->dollarUnitPkgAddp());
AstNode* newp = new AstArraySel( AstNode* newp = new AstArraySel(

4
test_regress/t/t_func_public.v
View File

@ -87,14 +87,14 @@ module tpub (
$c("publicNoArgs();"); $c("publicNoArgs();");
$c("publicSetBool(true);"); $c("publicSetBool(true);");
$c("publicSetLong(0x11bca);"); $c("publicSetLong(0x11bca);");
$c("publicSetQuad(VL_ULL(0x66655554444));"); $c("publicSetQuad(0x66655554444ULL);");
$c("publicSetFlop(0x321);"); $c("publicSetFlop(0x321);");
//Unsupported: $c("WData w[3] = {0x12, 0x5678_9123, 0x1245_2352}; publicSetWide(w);"); //Unsupported: $c("WData w[3] = {0x12, 0x5678_9123, 0x1245_2352}; publicSetWide(w);");
end end
if (cyc==12) begin if (cyc==12) begin
$c("got_bool = publicGetSetBool(true);"); $c("got_bool = publicGetSetBool(true);");
$c("got_long = publicGetSetLong(0x11bca);"); $c("got_long = publicGetSetLong(0x11bca);");
$c("got_quad = publicGetSetQuad(VL_ULL(0xaaaabbbbcccc));"); $c("got_quad = publicGetSetQuad(0xaaaabbbbccccULL);");
end end
if (cyc==13) begin if (cyc==13) begin
$c("{ bool gb; publicGetBool(gb); got_bool=gb; }"); $c("{ bool gb; publicGetBool(gb); got_bool=gb; }");

4
test_regress/t/t_order_quad.cpp
View File

@ -32,11 +32,11 @@ int main(int argc, char* argv[]) {
topp->a0 = 0; topp->a0 = 0;
topp->eval(); topp->eval();
check(topp->y, VL_ULL(0x0)); check(topp->y, 0x0ULL);
topp->a0 = 15; topp->a0 = 15;
topp->eval(); topp->eval();
check(topp->y, VL_ULL(0x3c00000000)); check(topp->y, 0x3c00000000ULL);
topp->final(); topp->final();
if (!fail) { if (!fail) {