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

Internals: Favor preincrement. No functional change.

This commit is contained in:
Wilson Snyder 2017-06-05 20:16:51 -04:00
parent f0fb3b78d1
commit 50c4f60c68
8 changed files with 155 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
include/verilated.cpp
View File

@ -115,7 +115,7 @@ QData VL_RANDOM_Q(int obits) {
} }
WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp) { WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp) {
for (int i=0; i<VL_WORDS_I(obits); i++) { for (int i=0; i<VL_WORDS_I(obits); ++i) {
if (i<(VL_WORDS_I(obits)-1)) { if (i<(VL_WORDS_I(obits)-1)) {
outwp[i] = VL_RAND32(); outwp[i] = VL_RAND32();
} else { } else {
@ -146,7 +146,7 @@ QData VL_RAND_RESET_Q(int obits) {
} }
WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) { WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) {
for (int i=0; i<VL_WORDS_I(obits); i++) { for (int i=0; i<VL_WORDS_I(obits); ++i) {
if (i<(VL_WORDS_I(obits)-1)) { if (i<(VL_WORDS_I(obits)-1)) {
outwp[i] = VL_RAND_RESET_I(32); outwp[i] = VL_RAND_RESET_I(32);
} else { } else {
@ -157,7 +157,7 @@ WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) {
} }
WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) { WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) {
for (int i=0; i<VL_WORDS_I(obits); i++) outwp[i] = 0; for (int i=0; i<VL_WORDS_I(obits); ++i) outwp[i] = 0;
return outwp; return outwp;
} }
@ -166,7 +166,7 @@ WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) {
void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp) { void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp) {
VL_PRINTF(" Data: w%d: ", lbits); VL_PRINTF(" Data: w%d: ", lbits);
for (int i=VL_WORDS_I(lbits)-1; i>=0; i--) { VL_PRINTF("%08x ",iwp[i]); } for (int i=VL_WORDS_I(lbits)-1; i>=0; --i) { VL_PRINTF("%08x ",iwp[i]); }
VL_PRINTF("\n"); VL_PRINTF("\n");
} }
@ -179,7 +179,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
// for debug see V3Number version // for debug see V3Number version
// Requires clean input // Requires clean input
int words = VL_WORDS_I(lbits); int words = VL_WORDS_I(lbits);
for (int i=0; i<words; i++) owp[i]=0; for (int i=0; i<words; ++i) owp[i]=0;
// Find MSB and check for zero. // Find MSB and check for zero.
int umsbp1 = VL_MOSTSETBITP1_W(words,lwp); // dividend int umsbp1 = VL_MOSTSETBITP1_W(words,lwp); // dividend
int vmsbp1 = VL_MOSTSETBITP1_W(words,rwp); // divisor int vmsbp1 = VL_MOSTSETBITP1_W(words,rwp); // divisor
@ -193,14 +193,14 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
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)) + (vluint64_t)(lwp[j])); vluint64_t unw64 = ((k<<VL_ULL(32)) + (vluint64_t)(lwp[j]));
owp[j] = unw64 / (vluint64_t)(rwp[0]); owp[j] = unw64 / (vluint64_t)(rwp[0]);
k = unw64 - (vluint64_t)(owp[j])*(vluint64_t)(rwp[0]); k = unw64 - (vluint64_t)(owp[j])*(vluint64_t)(rwp[0]);
} }
if (is_modulus) { if (is_modulus) {
owp[0] = k; owp[0] = k;
for (int i=1; i<words; i++) owp[i]=0; for (int i=1; i<words; ++i) owp[i]=0;
} }
return owp; return owp;
} }
@ -211,13 +211,13 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
// Zero for ease of debugging and to save having to zero for shifts // Zero for ease of debugging and to save having to zero for shifts
// Note +1 as loop will use extra word // Note +1 as loop will use extra word
for (int i=0; i<words+1; i++) { un[i]=vn[i]=0; } for (int i=0; i<words+1; ++i) { un[i]=vn[i]=0; }
// Algorithm requires divisor MSB to be set // Algorithm requires divisor MSB to be set
// Copy and shift to normalize divisor so MSB of vn[vw-1] is set // Copy and shift to normalize divisor so MSB of vn[vw-1] is set
int s = 31-VL_BITBIT_I(vmsbp1-1); // shift amount (0...31) int s = 31-VL_BITBIT_I(vmsbp1-1); // shift amount (0...31)
vluint32_t shift_mask = s ? 0xffffffff : 0; // otherwise >> 32 won't mask the value vluint32_t shift_mask = s ? 0xffffffff : 0; // otherwise >> 32 won't mask the value
for (int i = vw-1; i>0; i--) { for (int i = vw-1; i>0; --i) {
vn[i] = (rwp[i] << s) | (shift_mask & (rwp[i-1] >> (32-s))); vn[i] = (rwp[i] << s) | (shift_mask & (rwp[i-1] >> (32-s)));
} }
vn[0] = rwp[0] << s; vn[0] = rwp[0] << s;
@ -225,13 +225,13 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
// Copy and shift dividend by same amount; may set new upper word // Copy and shift dividend by same amount; may set new upper word
if (s) un[uw] = lwp[uw-1] >> (32-s); if (s) un[uw] = lwp[uw-1] >> (32-s);
else un[uw] = 0; else un[uw] = 0;
for (int i=uw-1; i>0; i--) { for (int i=uw-1; i>0; --i) {
un[i] = (lwp[i] << s) | (shift_mask & (lwp[i-1] >> (32-s))); un[i] = (lwp[i] << s) | (shift_mask & (lwp[i-1] >> (32-s)));
} }
un[0] = lwp[0] << s; un[0] = lwp[0] << s;
// 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 = ((vluint64_t)(un[j+vw])<<VL_ULL(32) | (vluint64_t)(un[j+vw-1])); vluint64_t unw64 = ((vluint64_t)(un[j+vw])<<VL_ULL(32) | (vluint64_t)(un[j+vw-1]));
vluint64_t qhat = unw64 / (vluint64_t)(vn[vw-1]); vluint64_t qhat = unw64 / (vluint64_t)(vn[vw-1]);
@ -247,7 +247,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
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 & VL_ULL(0xFFFFFFFF)); // Subtract
un[i+j] = t; un[i+j] = t;
@ -261,7 +261,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
// Over subtracted; correct by adding back // Over subtracted; correct by adding back
owp[j]--; owp[j]--;
k = 0; k = 0;
for (int i=0; i<vw; i++) { for (int i=0; i<vw; ++i) {
t = (vluint64_t)(un[i+j]) + (vluint64_t)(vn[i]) + k; t = (vluint64_t)(un[i+j]) + (vluint64_t)(vn[i]) + k;
un[i+j] = t; un[i+j] = t;
k = t >> VL_ULL(32); k = t >> VL_ULL(32);
@ -272,10 +272,10 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
if (is_modulus) { // modulus if (is_modulus) { // modulus
// Need to reverse normalization on copy to output // Need to reverse normalization on copy to output
for (int i=0; i<vw; i++) { for (int i=0; i<vw; ++i) {
owp[i] = (un[i] >> s) | (shift_mask & (un[i+1] << (32-s))); owp[i] = (un[i] >> s) | (shift_mask & (un[i+1] << (32-s)));
} }
for (int i=vw; i<words; i++) owp[i] = 0; for (int i=vw; i<words; ++i) owp[i] = 0;
return owp; return owp;
} else { // division } else { // division
return owp; return owp;
@ -376,7 +376,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
if (fmt == 'd' || fmt == '#') fmt = 'x'; // Not supported, but show something if (fmt == 'd' || fmt == '#') fmt = 'x'; // Not supported, but show something
} }
int lsb=lbits-1; int lsb=lbits-1;
if (widthSet && width==0) while (lsb && !VL_BITISSET_W(lwp,lsb)) lsb--; if (widthSet && width==0) while (lsb && !VL_BITISSET_W(lwp,lsb)) --lsb;
switch (fmt) { switch (fmt) {
case 'c': { case 'c': {
IData charval = ld & 0xff; IData charval = ld & 0xff;
@ -384,7 +384,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
break; break;
} }
case 's': case 's':
for (; lsb>=0; lsb--) { for (; lsb>=0; --lsb) {
lsb = (lsb / 8) * 8; // Next digit lsb = (lsb / 8) * 8; // Next digit
IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff; IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
output += (charval==0)?' ':charval; output += (charval==0)?' ':charval;
@ -433,13 +433,13 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
break; break;
} }
case 'b': case 'b':
for (; lsb>=0; lsb--) { for (; lsb>=0; --lsb) {
output += ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) + '0'; output += ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) + '0';
} }
break; break;
break; break;
case 'o': case 'o':
for (; lsb>=0; lsb--) { for (; lsb>=0; --lsb) {
lsb = (lsb / 3) * 3; // Next digit lsb = (lsb / 3) * 3; // Next digit
// Octal numbers may span more than one wide word, // Octal numbers may span more than one wide word,
// so we need to grab each bit separately and check for overrun // so we need to grab each bit separately and check for overrun
@ -452,7 +452,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
break; break;
case 'u': // Packed 2-state case 'u': // Packed 2-state
output.reserve(output.size() + 4*VL_WORDS_I(lbits)); output.reserve(output.size() + 4*VL_WORDS_I(lbits));
for (int i=0; i<VL_WORDS_I(lbits); i++) { for (int i=0; i<VL_WORDS_I(lbits); ++i) {
output += (char)((lwp[i] >> 0) & 0xff); output += (char)((lwp[i] >> 0) & 0xff);
output += (char)((lwp[i] >> 8) & 0xff); output += (char)((lwp[i] >> 8) & 0xff);
output += (char)((lwp[i] >> 16) & 0xff); output += (char)((lwp[i] >> 16) & 0xff);
@ -460,7 +460,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
} }
case 'z': // Packed 4-state case 'z': // Packed 4-state
output.reserve(output.size() + 8*VL_WORDS_I(lbits)); output.reserve(output.size() + 8*VL_WORDS_I(lbits));
for (int i=0; i<VL_WORDS_I(lbits); i++) { for (int i=0; i<VL_WORDS_I(lbits); ++i) {
output += (char)((lwp[i] >> 0) & 0xff); output += (char)((lwp[i] >> 0) & 0xff);
output += (char)((lwp[i] >> 8) & 0xff); output += (char)((lwp[i] >> 8) & 0xff);
output += (char)((lwp[i] >> 16) & 0xff); output += (char)((lwp[i] >> 16) & 0xff);
@ -468,12 +468,12 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
output += "\0\0\0\0"; // No tristate output += "\0\0\0\0"; // No tristate
} }
case 'v': // Strength; assume always strong case 'v': // Strength; assume always strong
for (lsb=lbits-1; lsb>=0; lsb--) { for (lsb=lbits-1; lsb>=0; --lsb) {
if ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) output += "St1 "; if ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) output += "St1 ";
else output += "St0 "; else output += "St0 ";
} }
case 'x': case 'x':
for (; lsb>=0; lsb--) { for (; lsb>=0; --lsb) {
lsb = (lsb / 4) * 4; // Next digit lsb = (lsb / 4) * 4; // Next digit
IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xf; IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xf;
output += "0123456789abcdef"[charval]; output += "0123456789abcdef"[charval];
@ -546,7 +546,7 @@ static inline void _vl_vsss_setbit(WDataOutP owp, int obits, int lsb, int nbits,
static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp, int posstart, int posend) { static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp, int posstart, int posend) {
// Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits. // Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits.
int lsb = 0; int lsb = 0;
for (int i=0, pos=posend-1; i<obits && pos>=posstart; pos--) { for (int i=0, pos=posend-1; i<obits && pos>=posstart; --pos) {
switch (tolower (strp[pos])) { switch (tolower (strp[pos])) {
case 'x': case 'z': case '?': //FALLTHRU case 'x': case 'z': case '?': //FALLTHRU
case '0': lsb += baseLog2; break; case '0': lsb += baseLog2; break;
@ -614,7 +614,7 @@ IData _vl_vsscanf(FILE* fp, // If a fscanf
if (obits > VL_QUADSIZE) { if (obits > VL_QUADSIZE) {
owp = va_arg(ap,WDataOutP); 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;
switch (fmt) { switch (fmt) {
case 'c': { case 'c': {
int c = _vl_vsss_peek(fp,floc,fromp,fstr); int c = _vl_vsss_peek(fp,floc,fromp,fstr);
@ -629,7 +629,7 @@ IData _vl_vsscanf(FILE* fp, // If a fscanf
if (!tmp[0]) goto done; if (!tmp[0]) goto done;
int pos = ((int)strlen(tmp))-1; int pos = ((int)strlen(tmp))-1;
int lsb = 0; int lsb = 0;
for (int i=0; i<obits && pos>=0; pos--) { for (int i=0; i<obits && pos>=0; --pos) {
_vl_vsss_setbit(owp,obits,lsb, 8, tmp[pos]); lsb+=8; _vl_vsss_setbit(owp,obits,lsb, 8, tmp[pos]); lsb+=8;
} }
break; break;
@ -723,7 +723,7 @@ void _VL_VINT_TO_STRING(int obits, char* destoutp, WDataInP sourcep) {
int lsb=obits-1; int lsb=obits-1;
bool start=true; bool start=true;
char* destp = destoutp; char* destp = destoutp;
for (; lsb>=0; lsb--) { for (; lsb>=0; --lsb) {
lsb = (lsb / 8) * 8; // Next digit lsb = (lsb / 8) * 8; // Next digit
IData charval = (sourcep[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff; IData charval = (sourcep[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
if (!start || charval) { if (!start || charval) {
@ -741,8 +741,8 @@ void _VL_STRING_TO_VINT(int obits, void* destp, int srclen, const char* srcp) {
char* op = ((char*)(destp)); char* op = ((char*)(destp));
if (srclen > bytes) srclen = bytes; // Don't overflow destination if (srclen > bytes) srclen = bytes; // Don't overflow destination
int i; int i;
for (i=0; i<srclen; i++) { *op++ = srcp[srclen-1-i]; } for (i=0; i<srclen; ++i) { *op++ = srcp[srclen-1-i]; }
for (; i<bytes; i++) { *op++ = 0; } for (; i<bytes; ++i) { *op++ = 0; }
} }
IData VL_FGETS_IXI(int obits, void* destp, IData fpi) { IData VL_FGETS_IXI(int obits, void* destp, IData fpi) {
@ -1122,7 +1122,7 @@ IData VL_VALUEPLUSARGS_INW(int rbits, const string& ld, WDataOutP rwp) {
_vl_vsss_based(rwp,rbits, 4, dp, 0, (int)strlen(dp)); _vl_vsss_based(rwp,rbits, 4, dp, 0, (int)strlen(dp));
break; break;
case 's': // string/no conversion case 's': // string/no conversion
for (int i=0, lsb=0, posp=((int)strlen(dp))-1; i<rbits && posp>=0; posp--) { for (int i=0, lsb=0, posp=((int)strlen(dp))-1; i<rbits && posp>=0; --posp) {
_vl_vsss_setbit(rwp,rbits,lsb, 8, dp[posp]); lsb+=8; _vl_vsss_setbit(rwp,rbits,lsb, 8, dp[posp]); lsb+=8;
} }
break; break;
@ -1184,7 +1184,7 @@ string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp) {
bool start=true; bool start=true;
char* destp = destout; char* destp = destout;
int len = 0; int len = 0;
for (; lsb>=0; lsb--) { for (; lsb>=0; --lsb) {
lsb = (lsb / 8) * 8; // Next digit lsb = (lsb / 8) * 8; // Next digit
IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff; IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
if (!start || charval) { if (!start || charval) {
@ -1403,7 +1403,7 @@ void* VerilatedScope::exportFindError(int funcnum) const {
void VerilatedScope::scopeDump() const { void VerilatedScope::scopeDump() const {
VL_PRINTF(" SCOPE %p: %s\n", this, name()); VL_PRINTF(" SCOPE %p: %s\n", this, name());
for (int i=0; i<m_funcnumMax; i++) { for (int i=0; i<m_funcnumMax; ++i) {
if (m_callbacksp && m_callbacksp[i]) { if (m_callbacksp && m_callbacksp[i]) {
VL_PRINTF(" DPI-EXPORT %p: %s\n", VL_PRINTF(" DPI-EXPORT %p: %s\n",
m_callbacksp[i], VerilatedImp::exportName(i)); m_callbacksp[i], VerilatedImp::exportName(i));

188
include/verilated.h
View File

@ -504,7 +504,7 @@ static inline WDataOutP _VL_CLEAN_INPLACE_W(int obits, WDataOutP owp) {
} }
static inline WDataOutP VL_CLEAN_WW(int obits, int, WDataOutP owp, WDataInP lwp){ static inline WDataOutP VL_CLEAN_WW(int obits, int, WDataOutP owp, WDataInP lwp){
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
for (int i=0; (i < (words-1)); i++) owp[i] = lwp[i]; for (int i=0; (i < (words-1)); ++i) owp[i] = lwp[i];
owp[words-1] = lwp[words-1] & VL_MASK_I(obits); owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
return(owp); return(owp);
} }
@ -519,7 +519,7 @@ static inline WDataOutP VL_ZERO_W(int obits, WDataOutP owp) {
// Note: If a ASSIGN isn't clean, use VL_ASSIGNCLEAN instead to do the same thing. // Note: If a ASSIGN isn't clean, use VL_ASSIGNCLEAN instead to do the same thing.
static inline WDataOutP VL_ASSIGN_W(int obits, WDataOutP owp,WDataInP lwp){ static inline WDataOutP VL_ASSIGN_W(int obits, WDataOutP owp,WDataInP lwp){
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
for (int i=0; i < words; i++) owp[i] = lwp[i]; for (int i=0; i < words; ++i) owp[i] = lwp[i];
return(owp); return(owp);
} }
@ -580,7 +580,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
} }
#define VL_ASSIGN_WSW(obits,owp,svar) { \ #define VL_ASSIGN_WSW(obits,owp,svar) { \
int words = VL_WORDS_I(obits); \ int words = VL_WORDS_I(obits); \
for (int i=0; i < words; i++) owp[i] = svar.read().get_word(i); \ for (int i=0; i < words; ++i) owp[i] = svar.read().get_word(i); \
owp[words-1] &= VL_MASK_I(obits); \ owp[words-1] &= VL_MASK_I(obits); \
} }
@ -589,7 +589,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
#define VL_ASSIGN_WSB(obits,owp,svar) { \ #define VL_ASSIGN_WSB(obits,owp,svar) { \
int words = VL_WORDS_I(obits); \ int words = VL_WORDS_I(obits); \
sc_biguint<obits> _butemp = (svar).read(); \ sc_biguint<obits> _butemp = (svar).read(); \
for (int i=0; i < words; i++) { \ for (int i=0; i < words; ++i) { \
int msb = ((i+1)*VL_WORDSIZE) - 1; \ int msb = ((i+1)*VL_WORDSIZE) - 1; \
msb = (msb >= obits) ? (obits-1) : msb; \ msb = (msb >= obits) ? (obits-1) : msb; \
owp[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint(); \ owp[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint(); \
@ -616,7 +616,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
} }
#define VL_ASSIGN_SWW(obits,svar,rwp) { \ #define VL_ASSIGN_SWW(obits,svar,rwp) { \
sc_bv<obits> _bvtemp; \ sc_bv<obits> _bvtemp; \
for (int i=0; i < VL_WORDS_I(obits); i++) _bvtemp.set_word(i,rwp[i]); \ for (int i=0; i < VL_WORDS_I(obits); ++i) _bvtemp.set_word(i,rwp[i]); \
svar.write(_bvtemp); \ svar.write(_bvtemp); \
} }
@ -626,7 +626,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
#define VL_ASSIGN_SBQ(obits,svar,rd) { (svar).write(rd); } #define VL_ASSIGN_SBQ(obits,svar,rd) { (svar).write(rd); }
#define VL_ASSIGN_SBW(obits,svar,rwp) { \ #define VL_ASSIGN_SBW(obits,svar,rwp) { \
sc_biguint<obits> _butemp; \ sc_biguint<obits> _butemp; \
for (int i=0; i < VL_WORDS_I(obits); i++) { \ for (int i=0; i < VL_WORDS_I(obits); ++i) { \
int msb = ((i+1)*VL_WORDSIZE) - 1; \ int msb = ((i+1)*VL_WORDSIZE) - 1; \
msb = (msb >= obits) ? (obits-1) : msb; \ msb = (msb >= obits) ? (obits-1) : msb; \
_butemp.range(msb,i*VL_WORDSIZE) = rwp[i]; \ _butemp.range(msb,i*VL_WORDSIZE) = rwp[i]; \
@ -648,17 +648,17 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
static inline WDataOutP VL_EXTEND_WI(int obits, int, WDataOutP owp, IData ld) { static inline WDataOutP VL_EXTEND_WI(int obits, int, WDataOutP owp, IData ld) {
// Note for extracts that obits != lbits // Note for extracts that obits != lbits
owp[0] = ld; owp[0] = ld;
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;
return(owp); return(owp);
} }
static inline WDataOutP VL_EXTEND_WQ(int obits, int, WDataOutP owp, QData ld) { static inline WDataOutP VL_EXTEND_WQ(int obits, int, WDataOutP owp, QData ld) {
VL_SET_WQ(owp,ld); VL_SET_WQ(owp,ld);
for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
return(owp); return(owp);
} }
static inline WDataOutP VL_EXTEND_WW(int obits, int lbits, WDataOutP owp, WDataInP lwp) { static inline WDataOutP VL_EXTEND_WW(int obits, int lbits, WDataOutP owp, WDataInP lwp) {
for (int i=0; i < VL_WORDS_I(lbits); i++) owp[i] = lwp[i]; for (int i=0; i < VL_WORDS_I(lbits); ++i) owp[i] = lwp[i];
for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
return(owp); return(owp);
} }
@ -677,22 +677,22 @@ static inline QData VL_EXTENDS_QQ(int, int lbits, QData lhs) {
static inline WDataOutP VL_EXTENDS_WI(int obits, int lbits, WDataOutP owp, IData ld) { static inline WDataOutP VL_EXTENDS_WI(int obits, int lbits, WDataOutP owp, IData ld) {
IData sign = VL_SIGNONES_I(lbits,ld); IData sign = VL_SIGNONES_I(lbits,ld);
owp[0] = ld | (sign & ~VL_MASK_I(lbits)); owp[0] = ld | (sign & ~VL_MASK_I(lbits));
for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = sign; for (int i=1; i < VL_WORDS_I(obits); ++i) owp[i] = sign;
return(owp); return(owp);
} }
static inline WDataOutP VL_EXTENDS_WQ(int obits, int lbits, WDataOutP owp, QData ld) { static inline WDataOutP VL_EXTENDS_WQ(int obits, int lbits, WDataOutP owp, QData ld) {
VL_SET_WQ(owp,ld); VL_SET_WQ(owp,ld);
IData sign = VL_SIGNONES_I(lbits,owp[1]); IData sign = VL_SIGNONES_I(lbits,owp[1]);
owp[1] |= sign & ~VL_MASK_I(lbits); owp[1] |= sign & ~VL_MASK_I(lbits);
for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = sign; for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = sign;
return(owp); return(owp);
} }
static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WDataInP lwp) { static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WDataInP lwp) {
for (int i=0; i < VL_WORDS_I(lbits)-1; i++) owp[i] = lwp[i]; for (int i=0; i < VL_WORDS_I(lbits)-1; ++i) owp[i] = lwp[i];
int lmsw=VL_WORDS_I(lbits)-1; int lmsw=VL_WORDS_I(lbits)-1;
IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]); IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
owp[lmsw] = lwp[lmsw] | (sign & ~VL_MASK_I(lbits)); owp[lmsw] = lwp[lmsw] | (sign & ~VL_MASK_I(lbits));
for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); i++) owp[i] = sign; for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); ++i) owp[i] = sign;
return(owp); return(owp);
} }
@ -705,7 +705,7 @@ static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WData
static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) { static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) {
int words = VL_WORDS_I(lbits); int words = VL_WORDS_I(lbits);
IData combine=lwp[0]; IData combine=lwp[0];
for (int i=1; i < words-1; i++) combine &= lwp[i]; for (int i=1; i < words-1; ++i) combine &= lwp[i];
combine &= ~VL_MASK_I(lbits) | lwp[words-1]; combine &= ~VL_MASK_I(lbits) | lwp[words-1];
return ((~combine)==0); return ((~combine)==0);
} }
@ -715,7 +715,7 @@ static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) {
#define VL_REDOR_Q(lhs) (lhs!=0) #define VL_REDOR_Q(lhs) (lhs!=0)
static inline IData VL_REDOR_W(int words, WDataInP lwp) { static inline IData VL_REDOR_W(int words, WDataInP lwp) {
IData equal=0; IData equal=0;
for (int i=0; i < words; i++) equal |= lwp[i]; for (int i=0; i < words; ++i) equal |= lwp[i];
return(equal!=0); return(equal!=0);
} }
@ -767,7 +767,7 @@ static inline IData VL_REDXOR_64(QData r) {
} }
static inline IData VL_REDXOR_W(int words, WDataInP lwp) { static inline IData VL_REDXOR_W(int words, WDataInP lwp) {
IData r = lwp[0]; IData r = lwp[0];
for (int i=1; i < words; i++) r ^= lwp[i]; for (int i=1; i < words; ++i) r ^= lwp[i];
return VL_REDXOR_32(r); return VL_REDXOR_32(r);
} }
@ -785,7 +785,7 @@ static inline IData VL_COUNTONES_Q(QData lhs) {
} }
static inline IData VL_COUNTONES_W(int words, WDataInP lwp) { static inline IData VL_COUNTONES_W(int words, WDataInP lwp) {
IData r = 0; IData r = 0;
for (int i=0; (i < words); i++) r+=VL_COUNTONES_I(lwp[i]); for (int i=0; (i < words); ++i) r+=VL_COUNTONES_I(lwp[i]);
return r; return r;
} }
@ -797,7 +797,7 @@ static inline IData VL_ONEHOT_Q(QData lhs) {
} }
static inline IData VL_ONEHOT_W(int words, WDataInP lwp) { static inline IData VL_ONEHOT_W(int words, WDataInP lwp) {
IData one=0; IData one=0;
for (int i=0; (i < words); i++) { for (int i=0; (i < words); ++i) {
if (lwp[i]) { if (lwp[i]) {
if (one) return 0; if (one) return 0;
one = 1; one = 1;
@ -815,7 +815,7 @@ static inline IData VL_ONEHOT0_Q(QData lhs) {
} }
static inline IData VL_ONEHOT0_W(int words, WDataInP lwp) { static inline IData VL_ONEHOT0_W(int words, WDataInP lwp) {
bool one=false; bool one=false;
for (int i=0; (i < words); i++) { for (int i=0; (i < words); ++i) {
if (lwp[i]) { if (lwp[i]) {
if (one) return 0; if (one) return 0;
one = true; one = true;
@ -830,21 +830,21 @@ static inline IData VL_CLOG2_I(IData lhs) {
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 >> 1; for (; lhs!=0; ++shifts) lhs = lhs >> 1;
return shifts; return shifts;
} }
static inline IData VL_CLOG2_Q(QData lhs) { static inline IData VL_CLOG2_Q(QData lhs) {
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 >> VL_ULL(1);
return shifts; return shifts;
} }
static inline IData VL_CLOG2_W(int words, WDataInP lwp) { static inline IData VL_CLOG2_W(int words, WDataInP lwp) {
IData adjust = (VL_COUNTONES_W(words,lwp)==1) ? 0 : 1; IData adjust = (VL_COUNTONES_W(words,lwp)==1) ? 0 : 1;
for (int i=words-1; i>=0; i--) { for (int i=words-1; i>=0; --i) {
if (VL_UNLIKELY(lwp[i])) { // Shorter worst case if predict not taken if (VL_UNLIKELY(lwp[i])) { // Shorter worst case if predict not taken
for (int bit=31; bit>=0; bit--) { for (int bit=31; bit>=0; --bit) {
if (VL_UNLIKELY(VL_BITISSET_I(lwp[i],bit))) { if (VL_UNLIKELY(VL_BITISSET_I(lwp[i],bit))) {
return i*VL_WORDSIZE + bit + adjust; return i*VL_WORDSIZE + bit + adjust;
} }
@ -857,9 +857,9 @@ static inline IData VL_CLOG2_W(int words, WDataInP lwp) {
static inline IData VL_MOSTSETBITP1_W(int words, WDataInP lwp) { static inline IData VL_MOSTSETBITP1_W(int words, WDataInP lwp) {
// MSB set bit plus one; similar to FLS. 0=value is zero // MSB set bit plus one; similar to FLS. 0=value is zero
for (int i=words-1; i>=0; i--) { for (int i=words-1; i>=0; --i) {
if (VL_UNLIKELY(lwp[i])) { // Shorter worst case if predict not taken if (VL_UNLIKELY(lwp[i])) { // Shorter worst case if predict not taken
for (int bit=31; bit>=0; bit--) { for (int bit=31; bit>=0; --bit) {
if (VL_UNLIKELY(VL_BITISSET_I(lwp[i],bit))) { if (VL_UNLIKELY(VL_BITISSET_I(lwp[i],bit))) {
return i*VL_WORDSIZE + bit + 1; return i*VL_WORDSIZE + bit + 1;
} }
@ -875,33 +875,33 @@ static inline IData VL_MOSTSETBITP1_W(int words, WDataInP lwp) {
// EMIT_RULE: VL_AND: oclean=lclean||rclean; obits=lbits; lbits==rbits; // EMIT_RULE: VL_AND: oclean=lclean||rclean; obits=lbits; lbits==rbits;
static inline WDataOutP VL_AND_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){ static inline WDataOutP VL_AND_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
for (int i=0; (i < words); i++) owp[i] = (lwp[i] & rwp[i]); for (int i=0; (i < words); ++i) owp[i] = (lwp[i] & rwp[i]);
return(owp); return(owp);
} }
// EMIT_RULE: VL_OR: oclean=lclean&&rclean; obits=lbits; lbits==rbits; // EMIT_RULE: VL_OR: oclean=lclean&&rclean; obits=lbits; lbits==rbits;
static inline WDataOutP VL_OR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){ static inline WDataOutP VL_OR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
for (int i=0; (i < words); i++) owp[i] = (lwp[i] | rwp[i]); for (int i=0; (i < words); ++i) owp[i] = (lwp[i] | rwp[i]);
return(owp); return(owp);
} }
// EMIT_RULE: VL_CHANGEXOR: oclean=1; obits=32; lbits==rbits; // EMIT_RULE: VL_CHANGEXOR: oclean=1; obits=32; lbits==rbits;
static inline IData VL_CHANGEXOR_W(int words, WDataInP lwp,WDataInP rwp){ static inline IData VL_CHANGEXOR_W(int words, WDataInP lwp,WDataInP rwp){
IData od = 0; IData od = 0;
for (int i=0; (i < words); i++) od |= (lwp[i] ^ rwp[i]); for (int i=0; (i < words); ++i) od |= (lwp[i] ^ rwp[i]);
return(od); return(od);
} }
// EMIT_RULE: VL_XOR: oclean=lclean&&rclean; obits=lbits; lbits==rbits; // EMIT_RULE: VL_XOR: oclean=lclean&&rclean; obits=lbits; lbits==rbits;
static inline WDataOutP VL_XOR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){ static inline WDataOutP VL_XOR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
for (int i=0; (i < words); i++) owp[i] = (lwp[i] ^ rwp[i]); for (int i=0; (i < words); ++i) owp[i] = (lwp[i] ^ rwp[i]);
return(owp); return(owp);
} }
// EMIT_RULE: VL_XNOR: oclean=dirty; obits=lbits; lbits==rbits; // EMIT_RULE: VL_XNOR: oclean=dirty; obits=lbits; lbits==rbits;
static inline WDataOutP VL_XNOR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){ static inline WDataOutP VL_XNOR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
for (int i=0; (i < words); i++) owp[i] = (lwp[i] ^ ~rwp[i]); for (int i=0; (i < words); ++i) owp[i] = (lwp[i] ^ ~rwp[i]);
return(owp); return(owp);
} }
// EMIT_RULE: VL_NOT: oclean=dirty; obits=lbits; // EMIT_RULE: VL_NOT: oclean=dirty; obits=lbits;
static inline WDataOutP VL_NOT_W(int words, WDataOutP owp,WDataInP lwp) { static inline WDataOutP VL_NOT_W(int words, WDataOutP owp,WDataInP lwp) {
for (int i=0; i < words; i++) owp[i] = ~(lwp[i]); for (int i=0; i < words; ++i) owp[i] = ~(lwp[i]);
return(owp); return(owp);
} }
@ -923,7 +923,7 @@ static inline WDataOutP VL_NOT_W(int words, WDataOutP owp,WDataInP lwp) {
// Output clean, <lhs> AND <rhs> MUST BE CLEAN // Output clean, <lhs> AND <rhs> MUST BE CLEAN
static inline IData VL_EQ_W(int words, WDataInP lwp, WDataInP rwp) { static inline IData VL_EQ_W(int words, WDataInP lwp, WDataInP rwp) {
int nequal=0; int nequal=0;
for (int i=0; (i < words); i++) nequal |= (lwp[i] ^ rwp[i]); for (int i=0; (i < words); ++i) nequal |= (lwp[i] ^ rwp[i]);
return(nequal==0); return(nequal==0);
} }
@ -1017,7 +1017,7 @@ static inline int _VL_CMPS_W(int lbits, WDataInP lwp, WDataInP rwp) {
static inline WDataOutP VL_ADD_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){ static inline WDataOutP VL_ADD_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
QData carry = 0; QData carry = 0;
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
carry = carry + (QData)(lwp[i]) + (QData)(rwp[i]); carry = carry + (QData)(lwp[i]) + (QData)(rwp[i]);
owp[i] = (carry & VL_ULL(0xffffffff)); owp[i] = (carry & VL_ULL(0xffffffff));
carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff); carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff);
@ -1027,7 +1027,7 @@ static inline WDataOutP VL_ADD_W(int words, WDataOutP owp,WDataInP lwp,WDataInP
static inline WDataOutP VL_SUB_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){ static inline WDataOutP VL_SUB_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
QData carry = 0; QData carry = 0;
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
carry = carry + (QData)(lwp[i]) + (QData)(IData)(~rwp[i]); carry = carry + (QData)(lwp[i]) + (QData)(IData)(~rwp[i]);
if (i==0) carry++; // Negation of temp2 if (i==0) carry++; // Negation of temp2
owp[i] = (carry & VL_ULL(0xffffffff)); owp[i] = (carry & VL_ULL(0xffffffff));
@ -1044,7 +1044,7 @@ static inline QData VL_NEGATE_Q(QData data) { return -data; }
static inline WDataOutP VL_NEGATE_W(int words, WDataOutP owp,WDataInP lwp){ static inline WDataOutP VL_NEGATE_W(int words, WDataOutP owp,WDataInP lwp){
QData carry = 0; QData carry = 0;
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
carry = carry + (QData)(IData)(~lwp[i]); carry = carry + (QData)(IData)(~lwp[i]);
if (i==0) carry++; // Negation of temp2 if (i==0) carry++; // Negation of temp2
owp[i] = (carry & VL_ULL(0xffffffff)); owp[i] = (carry & VL_ULL(0xffffffff));
@ -1054,11 +1054,11 @@ static inline WDataOutP VL_NEGATE_W(int words, WDataOutP owp,WDataInP lwp){
} }
static inline WDataOutP VL_MUL_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){ static inline WDataOutP VL_MUL_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
for (int i=0; i<words; i++) owp[i] = 0; for (int i=0; i<words; ++i) owp[i] = 0;
for (int lword=0; lword<words; lword++) { for (int lword=0; lword<words; ++lword) {
for (int rword=0; rword<words; rword++) { for (int rword=0; rword<words; ++rword) {
QData mul = (QData)(lwp[lword]) * (QData)(rwp[rword]); QData mul = (QData)(lwp[lword]) * (QData)(rwp[rword]);
for (int qword=lword+rword; qword<words; qword++) { for (int qword=lword+rword; qword<words; ++qword) {
mul += (QData)(owp[qword]); mul += (QData)(owp[qword]);
owp[qword] = (mul & VL_ULL(0xffffffff)); owp[qword] = (mul & VL_ULL(0xffffffff));
mul = (mul >> VL_ULL(32)) & VL_ULL(0xffffffff); mul = (mul >> VL_ULL(32)) & VL_ULL(0xffffffff);
@ -1104,7 +1104,7 @@ static inline WDataOutP VL_MULS_WWW(int,int lbits,int, WDataOutP owp,WDataInP lw
owp[words-1] &= VL_MASK_I(lbits); // Clean. Note it's ok for the multiply to overflow into the sign bit owp[words-1] &= VL_MASK_I(lbits); // Clean. Note it's ok for the multiply to overflow into the sign bit
if ((lneg ^ rneg) & 1) { // Negate output (not using NEGATE, as owp==lwp) if ((lneg ^ rneg) & 1) { // Negate output (not using NEGATE, as owp==lwp)
QData carry = 0; QData carry = 0;
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
carry = carry + (QData)(IData)(~owp[i]); carry = carry + (QData)(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 & VL_ULL(0xffffffff));
@ -1191,7 +1191,7 @@ static inline IData VL_POW_III(int, int, int rbits, IData lhs, IData rhs) {
if (VL_UNLIKELY(lhs==0)) return 0; if (VL_UNLIKELY(lhs==0)) return 0;
IData power = lhs; IData power = lhs;
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 & (VL_ULL(1)<<i)) out *= power;
} }
@ -1202,7 +1202,7 @@ static inline QData VL_POW_QQQ(int, int, int rbits, QData lhs, QData rhs) {
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 = VL_ULL(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 & (VL_ULL(1)<<i)) out *= power;
} }
@ -1292,13 +1292,13 @@ static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int
int words = VL_WORDS_I(hbit-lbit+1); int words = VL_WORDS_I(hbit-lbit+1);
if (hoffset==VL_SIZEBITS_I && loffset==0) { if (hoffset==VL_SIZEBITS_I && loffset==0) {
// Fast and common case, word based insertion // Fast and common case, word based insertion
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
owp[lword+i] = lwp[i]; owp[lword+i] = lwp[i];
} }
} }
else if (loffset==0) { else if (loffset==0) {
// Non-32bit, but nicely aligned, so stuff all but the last word // Non-32bit, but nicely aligned, so stuff all but the last word
for (int i=0; i<(words-1); i++) { for (int i=0; i<(words-1); ++i) {
owp[lword+i] = lwp[i]; owp[lword+i] = lwp[i];
} }
IData hinsmask = (VL_MASK_I(hoffset-0+1)); // Know it's not a full word as above fast case handled it IData hinsmask = (VL_MASK_I(hoffset-0+1)); // Know it's not a full word as above fast case handled it
@ -1310,7 +1310,7 @@ static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int
int nbitsonright = 32-loffset; // bits that end up in lword (know loffset!=0) int nbitsonright = 32-loffset; // bits that end up in lword (know loffset!=0)
// Middle words // Middle words
int hword = VL_BITWORD_I(hbit); int hword = VL_BITWORD_I(hbit);
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
{ // Lower word { // Lower word
int oword = lword+i; int oword = lword+i;
IData d = lwp[i]<<loffset; IData d = lwp[i]<<loffset;
@ -1343,7 +1343,7 @@ static inline void _VL_INSERT_WQ(int obits, WDataOutP owp, QData ld, int hbit, i
static inline IData VL_REPLICATE_III(int, int lbits, int, IData ld, IData rep) { static inline IData VL_REPLICATE_III(int, int lbits, int, IData ld, IData rep) {
IData returndata = ld; IData returndata = ld;
for (unsigned i=1; i < rep; i++){ for (unsigned i=1; i < rep; ++i){
returndata = returndata << lbits; returndata = returndata << lbits;
returndata |= ld; returndata |= ld;
} }
@ -1351,7 +1351,7 @@ static inline IData VL_REPLICATE_III(int, int lbits, int, IData ld, IData rep) {
} }
static inline QData VL_REPLICATE_QII(int, int lbits, int, IData ld, IData rep) { static inline QData VL_REPLICATE_QII(int, int lbits, int, IData ld, IData rep) {
QData returndata = ld; QData returndata = ld;
for (unsigned i=1; i < rep; i++){ for (unsigned i=1; i < rep; ++i){
returndata = returndata << lbits; returndata = returndata << lbits;
returndata |= (QData)ld; returndata |= (QData)ld;
} }
@ -1359,21 +1359,21 @@ static inline QData VL_REPLICATE_QII(int, int lbits, int, IData ld, IData rep) {
} }
static inline WDataOutP VL_REPLICATE_WII(int obits, int lbits, int, WDataOutP owp, IData ld, IData rep) { static inline WDataOutP VL_REPLICATE_WII(int obits, int lbits, int, WDataOutP owp, IData ld, IData rep) {
owp[0] = ld; owp[0] = ld;
for (unsigned i=1; i < rep; i++){ for (unsigned i=1; i < rep; ++i){
_VL_INSERT_WI(obits,owp,ld,i*lbits+lbits-1,i*lbits); _VL_INSERT_WI(obits,owp,ld,i*lbits+lbits-1,i*lbits);
} }
return(owp); return(owp);
} }
static inline WDataOutP VL_REPLICATE_WQI(int obits, int lbits, int, WDataOutP owp, QData ld, IData rep) { static inline WDataOutP VL_REPLICATE_WQI(int obits, int lbits, int, WDataOutP owp, QData ld, IData rep) {
VL_SET_WQ(owp,ld); VL_SET_WQ(owp,ld);
for (unsigned i=1; i < rep; i++){ for (unsigned i=1; i < rep; ++i){
_VL_INSERT_WQ(obits,owp,ld,i*lbits+lbits-1,i*lbits); _VL_INSERT_WQ(obits,owp,ld,i*lbits+lbits-1,i*lbits);
} }
return(owp); return(owp);
} }
static inline WDataOutP VL_REPLICATE_WWI(int obits, int lbits, int, WDataOutP owp, WDataInP lwp, IData rep) { static inline WDataOutP VL_REPLICATE_WWI(int obits, int lbits, int, WDataOutP owp, WDataInP lwp, IData rep) {
for (int i=0; i < VL_WORDS_I(lbits); i++) owp[i] = lwp[i]; for (int i=0; i < VL_WORDS_I(lbits); ++i) owp[i] = lwp[i];
for (unsigned i=1; i < rep; i++){ for (unsigned i=1; i < rep; ++i){
_VL_INSERT_WW(obits,owp,lwp,i*lbits+lbits-1,i*lbits); _VL_INSERT_WW(obits,owp,lwp,i*lbits+lbits-1,i*lbits);
} }
return(owp); return(owp);
@ -1483,7 +1483,7 @@ static inline WDataOutP VL_STREAML_WWI(int, int lbits, int, WDataOutP owp, WData
for (int istart=0; istart<lbits; istart+=rd) { for (int istart=0; istart<lbits; istart+=rd) {
int ostart=lbits-rd-istart; int ostart=lbits-rd-istart;
ostart = ostart > 0 ? ostart : 0; ostart = ostart > 0 ? ostart : 0;
for (int sbit=0; sbit<ssize && sbit<lbits-istart; sbit++) { for (int sbit=0; sbit<ssize && sbit<lbits-istart; ++sbit) {
// Extract a single bit from lwp and shift it to the correct // Extract a single bit from lwp and shift it to the correct
// location for owp. // location for owp.
WData bit= ((lwp[VL_BITWORD_I(istart+sbit)] >> VL_BITBIT_I(istart+sbit)) & 1) << VL_BITBIT_I(ostart+sbit); WData bit= ((lwp[VL_BITWORD_I(istart+sbit)] >> VL_BITBIT_I(istart+sbit)) & 1) << VL_BITBIT_I(ostart+sbit);
@ -1505,55 +1505,55 @@ static inline WDataOutP VL_STREAML_WWI(int, int lbits, int, WDataOutP owp, WData
static inline WDataOutP VL_CONCAT_WII(int obits,int lbits,int rbits,WDataOutP owp,IData ld,IData rd) { static inline WDataOutP VL_CONCAT_WII(int obits,int lbits,int rbits,WDataOutP owp,IData ld,IData rd) {
owp[0] = rd; owp[0] = rd;
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;
_VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits); _VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WWI(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, IData rd) { static inline WDataOutP VL_CONCAT_WWI(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, IData rd) {
owp[0] = rd; owp[0] = rd;
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;
_VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits); _VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WIW(int obits,int lbits,int rbits,WDataOutP owp,IData ld, WDataInP rwp) { static inline WDataOutP VL_CONCAT_WIW(int obits,int lbits,int rbits,WDataOutP owp,IData ld, WDataInP rwp) {
for (int i=0; i < VL_WORDS_I(rbits); i++) owp[i] = rwp[i]; for (int i=0; i < VL_WORDS_I(rbits); ++i) owp[i] = rwp[i];
for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
_VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits); _VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WIQ(int obits,int lbits,int rbits,WDataOutP owp,IData ld,QData rd) { static inline WDataOutP VL_CONCAT_WIQ(int obits,int lbits,int rbits,WDataOutP owp,IData ld,QData rd) {
VL_SET_WQ(owp,rd); VL_SET_WQ(owp,rd);
for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
_VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits); _VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WQI(int obits,int lbits,int rbits,WDataOutP owp,QData ld,IData rd) { static inline WDataOutP VL_CONCAT_WQI(int obits,int lbits,int rbits,WDataOutP owp,QData ld,IData rd) {
owp[0] = rd; owp[0] = rd;
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;
_VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits); _VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WQQ(int obits,int lbits,int rbits,WDataOutP owp,QData ld,QData rd) { static inline WDataOutP VL_CONCAT_WQQ(int obits,int lbits,int rbits,WDataOutP owp,QData ld,QData rd) {
VL_SET_WQ(owp,rd); VL_SET_WQ(owp,rd);
for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
_VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits); _VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WWQ(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, QData rd) { static inline WDataOutP VL_CONCAT_WWQ(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, QData rd) {
VL_SET_WQ(owp,rd); VL_SET_WQ(owp,rd);
for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
_VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits); _VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WQW(int obits,int lbits,int rbits,WDataOutP owp,QData ld, WDataInP rwp) { static inline WDataOutP VL_CONCAT_WQW(int obits,int lbits,int rbits,WDataOutP owp,QData ld, WDataInP rwp) {
for (int i=0; i < VL_WORDS_I(rbits); i++) owp[i] = rwp[i]; for (int i=0; i < VL_WORDS_I(rbits); ++i) owp[i] = rwp[i];
for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
_VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits); _VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
static inline WDataOutP VL_CONCAT_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) { static inline WDataOutP VL_CONCAT_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
for (int i=0; i < VL_WORDS_I(rbits); i++) owp[i] = rwp[i]; for (int i=0; i < VL_WORDS_I(rbits); ++i) owp[i] = rwp[i];
for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
_VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits); _VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits);
return(owp); return(owp);
} }
@ -1566,7 +1566,7 @@ static inline WDataOutP VL_CONCAT_WWW(int obits,int lbits,int rbits,WDataOutP ow
static inline void _VL_SHIFTL_INPLACE_W(int obits,WDataOutP iowp,IData rd/*1 or 4*/) { static inline void _VL_SHIFTL_INPLACE_W(int obits,WDataOutP iowp,IData rd/*1 or 4*/) {
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
IData linsmask = VL_MASK_I(rd); IData linsmask = VL_MASK_I(rd);
for (int i=words-1; i>=1; i--) { for (int i=words-1; i>=1; --i) {
iowp[i] = ((iowp[i]<<rd) & ~linsmask) | ((iowp[i-1] >> (32-rd)) & linsmask); iowp[i] = ((iowp[i]<<rd) & ~linsmask) | ((iowp[i-1] >> (32-rd)) & linsmask);
} }
iowp[0] = ((iowp[0]<<rd) & ~linsmask); iowp[0] = ((iowp[0]<<rd) & ~linsmask);
@ -1580,18 +1580,18 @@ static inline WDataOutP VL_SHIFTL_WWI(int obits,int,int,WDataOutP owp,WDataInP l
int word_shift = VL_BITWORD_I(rd); int word_shift = VL_BITWORD_I(rd);
int bit_shift = VL_BITBIT_I(rd); int bit_shift = VL_BITBIT_I(rd);
if (rd >= (IData)obits) { // rd may be huge with MSB set if (rd >= (IData)obits) { // rd may be huge with MSB set
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;
} else if (bit_shift==0) { // Aligned word shift (<<0,<<32,<<64 etc) } else if (bit_shift==0) { // Aligned word shift (<<0,<<32,<<64 etc)
for (int i=0; i < word_shift; i++) owp[i] = 0; for (int i=0; i < word_shift; ++i) owp[i] = 0;
for (int i=word_shift; i < VL_WORDS_I(obits); i++) owp[i] = lwp[i-word_shift]; for (int i=word_shift; i < VL_WORDS_I(obits); ++i) owp[i] = lwp[i-word_shift];
} else { } else {
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;
_VL_INSERT_WW(obits,owp,lwp,obits-1,rd); _VL_INSERT_WW(obits,owp,lwp,obits-1,rd);
} }
return(owp); return(owp);
} }
static inline WDataOutP VL_SHIFTL_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) { static inline WDataOutP VL_SHIFTL_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
for (int i=1; i < VL_WORDS_I(rbits); i++) { for (int i=1; i < VL_WORDS_I(rbits); ++i) {
if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
return VL_ZERO_W(obits, owp); return VL_ZERO_W(obits, owp);
} }
@ -1599,7 +1599,7 @@ static inline WDataOutP VL_SHIFTL_WWW(int obits,int lbits,int rbits,WDataOutP ow
return VL_SHIFTL_WWI(obits,lbits,32,owp,lwp,rwp[0]); return VL_SHIFTL_WWI(obits,lbits,32,owp,lwp,rwp[0]);
} }
static inline IData VL_SHIFTL_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) { static inline IData VL_SHIFTL_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) {
for (int i=1; i < VL_WORDS_I(rbits); i++) { for (int i=1; i < VL_WORDS_I(rbits); ++i) {
if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
return 0; return 0;
} }
@ -1614,29 +1614,29 @@ static inline WDataOutP VL_SHIFTR_WWI(int obits,int,int,WDataOutP owp,WDataInP l
int word_shift = VL_BITWORD_I(rd); // Maybe 0 int word_shift = VL_BITWORD_I(rd); // Maybe 0
int bit_shift = VL_BITBIT_I(rd); int bit_shift = VL_BITBIT_I(rd);
if (rd >= (IData)obits) { // rd may be huge with MSB set if (rd >= (IData)obits) { // rd may be huge with MSB set
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;
} else if (bit_shift==0) { // Aligned word shift (>>0,>>32,>>64 etc) } else if (bit_shift==0) { // Aligned word shift (>>0,>>32,>>64 etc)
int copy_words = (VL_WORDS_I(obits)-word_shift); int copy_words = (VL_WORDS_I(obits)-word_shift);
for (int i=0; i < copy_words; i++) owp[i] = lwp[i+word_shift]; for (int i=0; i < copy_words; ++i) owp[i] = lwp[i+word_shift];
for (int i=copy_words; i < VL_WORDS_I(obits); i++) owp[i] = 0; for (int i=copy_words; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
} else { } else {
int loffset = rd & VL_SIZEBITS_I; int loffset = rd & VL_SIZEBITS_I;
int nbitsonright = 32-loffset; // bits that end up in lword (know loffset!=0) int nbitsonright = 32-loffset; // bits that end up in lword (know loffset!=0)
// Middle words // Middle words
int words = VL_WORDS_I(obits-rd); int words = VL_WORDS_I(obits-rd);
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
owp[i] = lwp[i+word_shift]>>loffset; owp[i] = lwp[i+word_shift]>>loffset;
int upperword = i+word_shift+1; int upperword = i+word_shift+1;
if (upperword < VL_WORDS_I(obits)) { if (upperword < VL_WORDS_I(obits)) {
owp[i] |= lwp[upperword]<< nbitsonright; owp[i] |= lwp[upperword]<< nbitsonright;
} }
} }
for (int i=words; i<VL_WORDS_I(obits); i++) owp[i]=0; for (int i=words; i<VL_WORDS_I(obits); ++i) owp[i]=0;
} }
return(owp); return(owp);
} }
static inline WDataOutP VL_SHIFTR_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) { static inline WDataOutP VL_SHIFTR_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
for (int i=1; i < VL_WORDS_I(rbits); i++) { for (int i=1; i < VL_WORDS_I(rbits); ++i) {
if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
return VL_ZERO_W(obits, owp); return VL_ZERO_W(obits, owp);
} }
@ -1644,7 +1644,7 @@ static inline WDataOutP VL_SHIFTR_WWW(int obits,int lbits,int rbits,WDataOutP ow
return VL_SHIFTR_WWI(obits,lbits,32,owp,lwp,rwp[0]); return VL_SHIFTR_WWI(obits,lbits,32,owp,lwp,rwp[0]);
} }
static inline IData VL_SHIFTR_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) { static inline IData VL_SHIFTR_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) {
for (int i=1; i < VL_WORDS_I(rbits); i++) { for (int i=1; i < VL_WORDS_I(rbits); ++i) {
if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
return 0; return 0;
} }
@ -1676,20 +1676,20 @@ static inline WDataOutP VL_SHIFTRS_WWI(int obits,int lbits,int,WDataOutP owp,WDa
int lmsw = VL_WORDS_I(obits)-1; int lmsw = VL_WORDS_I(obits)-1;
IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]); IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
if (rd >= (IData)obits) { // Shifting past end, sign in all of lbits if (rd >= (IData)obits) { // Shifting past end, sign in all of lbits
for (int i=0; i <= lmsw; i++) owp[i] = sign; for (int i=0; i <= lmsw; ++i) owp[i] = sign;
owp[lmsw] &= VL_MASK_I(lbits); owp[lmsw] &= VL_MASK_I(lbits);
} else if (bit_shift==0) { // Aligned word shift (>>0,>>32,>>64 etc) } else if (bit_shift==0) { // Aligned word shift (>>0,>>32,>>64 etc)
int copy_words = (VL_WORDS_I(obits)-word_shift); int copy_words = (VL_WORDS_I(obits)-word_shift);
for (int i=0; i < copy_words; i++) owp[i] = lwp[i+word_shift]; for (int i=0; i < copy_words; ++i) owp[i] = lwp[i+word_shift];
if (copy_words>=0) owp[copy_words-1] |= ~VL_MASK_I(obits) & sign; if (copy_words>=0) owp[copy_words-1] |= ~VL_MASK_I(obits) & sign;
for (int i=copy_words; i < VL_WORDS_I(obits); i++) owp[i] = sign; for (int i=copy_words; i < VL_WORDS_I(obits); ++i) owp[i] = sign;
owp[lmsw] &= VL_MASK_I(lbits); owp[lmsw] &= VL_MASK_I(lbits);
} else { } else {
int loffset = rd & VL_SIZEBITS_I; int loffset = rd & VL_SIZEBITS_I;
int nbitsonright = 32-loffset; // bits that end up in lword (know loffset!=0) int nbitsonright = 32-loffset; // bits that end up in lword (know loffset!=0)
// Middle words // Middle words
int words = VL_WORDS_I(obits-rd); int words = VL_WORDS_I(obits-rd);
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
owp[i] = lwp[i+word_shift]>>loffset; owp[i] = lwp[i+word_shift]>>loffset;
int upperword = i+word_shift+1; int upperword = i+word_shift+1;
if (upperword < VL_WORDS_I(obits)) { if (upperword < VL_WORDS_I(obits)) {
@ -1697,17 +1697,17 @@ static inline WDataOutP VL_SHIFTRS_WWI(int obits,int lbits,int,WDataOutP owp,WDa
} }
} }
if (words) owp[words-1] |= sign & ~VL_MASK_I(obits-loffset); if (words) owp[words-1] |= sign & ~VL_MASK_I(obits-loffset);
for (int i=words; i<VL_WORDS_I(obits); i++) owp[i] = sign; for (int i=words; i<VL_WORDS_I(obits); ++i) owp[i] = sign;
owp[lmsw] &= VL_MASK_I(lbits); owp[lmsw] &= VL_MASK_I(lbits);
} }
return(owp); return(owp);
} }
static inline WDataOutP VL_SHIFTRS_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) { static inline WDataOutP VL_SHIFTRS_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
for (int i=1; i < VL_WORDS_I(rbits); i++) { for (int i=1; i < VL_WORDS_I(rbits); ++i) {
if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
int lmsw = VL_WORDS_I(obits)-1; int lmsw = VL_WORDS_I(obits)-1;
IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]); IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
for (int i=0; i <= lmsw; i++) owp[i] = sign; for (int i=0; i <= lmsw; ++i) owp[i] = sign;
owp[lmsw] &= VL_MASK_I(lbits); owp[lmsw] &= VL_MASK_I(lbits);
return owp; return owp;
} }
@ -1715,7 +1715,7 @@ static inline WDataOutP VL_SHIFTRS_WWW(int obits,int lbits,int rbits,WDataOutP o
return VL_SHIFTRS_WWI(obits,lbits,32,owp,lwp,rwp[0]); return VL_SHIFTRS_WWI(obits,lbits,32,owp,lwp,rwp[0]);
} }
static inline IData VL_SHIFTRS_IIW(int obits,int lbits,int rbits,IData lhs, WDataInP rwp) { static inline IData VL_SHIFTRS_IIW(int obits,int lbits,int rbits,IData lhs, WDataInP rwp) {
for (int i=1; i < VL_WORDS_I(rbits); i++) { for (int i=1; i < VL_WORDS_I(rbits); ++i) {
if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
IData sign = -(lhs >> (lbits-1)); // ffff_ffff if negative IData sign = -(lhs >> (lbits-1)); // ffff_ffff if negative
return VL_CLEAN_II(obits,obits,sign); return VL_CLEAN_II(obits,obits,sign);
@ -1724,7 +1724,7 @@ static inline IData VL_SHIFTRS_IIW(int obits,int lbits,int rbits,IData lhs, WDat
return VL_SHIFTRS_III(obits,lbits,32,lhs,rwp[0]); return VL_SHIFTRS_III(obits,lbits,32,lhs,rwp[0]);
} }
static inline QData VL_SHIFTRS_QQW(int obits,int lbits,int rbits,QData lhs, WDataInP rwp) { static inline QData VL_SHIFTRS_QQW(int obits,int lbits,int rbits,QData lhs, WDataInP rwp) {
for (int i=1; i < VL_WORDS_I(rbits); i++) { for (int i=1; i < VL_WORDS_I(rbits); ++i) {
if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
QData sign = -(lhs >> (lbits-1)); // ffff_ffff if negative QData sign = -(lhs >> (lbits-1)); // ffff_ffff if negative
return VL_CLEAN_QQ(obits,obits,sign); return VL_CLEAN_QQ(obits,obits,sign);
@ -1805,25 +1805,25 @@ static inline WDataOutP VL_SEL_WWII(int obits,int lbits,int,int,WDataOutP owp,WD
int msb = lsb+width-1; int msb = lsb+width-1;
int word_shift = VL_BITWORD_I(lsb); int word_shift = VL_BITWORD_I(lsb);
if (VL_UNLIKELY(msb>lbits)) { // Outside bounds, if (VL_UNLIKELY(msb>lbits)) { // Outside bounds,
for (int i=0; i<VL_WORDS_I(obits)-1; i++) owp[i] = ~0; for (int i=0; i<VL_WORDS_I(obits)-1; ++i) owp[i] = ~0;
owp[VL_WORDS_I(obits)-1] = VL_MASK_I(obits); owp[VL_WORDS_I(obits)-1] = VL_MASK_I(obits);
} else if (VL_BITBIT_I(lsb)==0) { } else if (VL_BITBIT_I(lsb)==0) {
// Just a word extract // Just a word extract
for (int i=0; i<VL_WORDS_I(obits); i++) owp[i] = lwp[i+word_shift]; for (int i=0; i<VL_WORDS_I(obits); ++i) owp[i] = lwp[i+word_shift];
} else { } else {
// Not a _VL_INSERT because the bits come from any bit number and goto bit 0 // Not a _VL_INSERT because the bits come from any bit number and goto bit 0
int loffset = lsb & VL_SIZEBITS_I; int loffset = lsb & VL_SIZEBITS_I;
int nbitsfromlow = 32-loffset; // bits that end up in lword (know loffset!=0) int nbitsfromlow = 32-loffset; // bits that end up in lword (know loffset!=0)
// Middle words // Middle words
int words = VL_WORDS_I(msb-lsb+1); int words = VL_WORDS_I(msb-lsb+1);
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
owp[i] = lwp[i+word_shift]>>loffset; owp[i] = lwp[i+word_shift]>>loffset;
int upperword = i+word_shift+1; int upperword = i+word_shift+1;
if (upperword <= (int)VL_BITWORD_I(msb)) { if (upperword <= (int)VL_BITWORD_I(msb)) {
owp[i] |= lwp[upperword]<< nbitsfromlow; owp[i] |= lwp[upperword]<< nbitsfromlow;
} }
} }
for (int i=words; i<VL_WORDS_I(obits); i++) owp[i]=0; for (int i=words; i<VL_WORDS_I(obits); ++i) owp[i]=0;
} }
return owp; return owp;
} }
@ -1868,7 +1868,7 @@ static inline void VL_ASSIGNSEL_WIIW(int obits, int lsb, WDataOutP owp, WDataInP
static inline WDataOutP VL_COND_WIWW(int obits, int, int, int, static inline WDataOutP VL_COND_WIWW(int obits, int, int, int,
WDataOutP owp, int cond, WDataInP w1p, WDataInP w2p) { WDataOutP owp, int cond, WDataInP w1p, WDataInP w2p) {
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
for (int i=0; i < words; i++) owp[i] = cond ? w1p[i] : w2p[i]; for (int i=0; i < words; ++i) owp[i] = cond ? w1p[i] : w2p[i];
return(owp); return(owp);
} }
@ -1901,7 +1901,7 @@ inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, IData
// If changing the number of functions here, also change EMITCINLINES_NUM_CONSTW // If changing the number of functions here, also change EMITCINLINES_NUM_CONSTW
#define _END(obits,wordsSet) \ #define _END(obits,wordsSet) \
for(int i=(wordsSet);i<VL_WORDS_I(obits);i++) o[i] = (IData)0x0; \ for(int i=(wordsSet);i<VL_WORDS_I(obits);++i) o[i] = (IData)0x0; \
return o return o
#define VL_HAVE_CONST_W_1X #define VL_HAVE_CONST_W_1X

16
include/verilated_cov.cpp
View File

@ -50,7 +50,7 @@ public: // But only local to this file
// CONSTRUCTORS // CONSTRUCTORS
// Derived classes should call zero() in their constructor // Derived classes should call zero() in their constructor
VerilatedCovImpItem() { VerilatedCovImpItem() {
for (int i=0; i<MAX_KEYS; i++) { for (int i=0; i<MAX_KEYS; ++i) {
m_keys[i]=KEY_UNDEF; m_keys[i]=KEY_UNDEF;
m_vals[i]=0; m_vals[i]=0;
} }
@ -130,7 +130,7 @@ private:
string dequote(const string& text) { string dequote(const string& text) {
// Quote any special characters // Quote any special characters
string rtn; string rtn;
for (const char* pos = text.c_str(); *pos; pos++) { for (const char* pos = text.c_str(); *pos; ++pos) {
if (!isprint(*pos) || *pos=='%' || *pos=='"') { if (!isprint(*pos) || *pos=='%' || *pos=='"') {
char hex[10]; sprintf(hex,"%%%02X",pos[0]); char hex[10]; sprintf(hex,"%%%02X",pos[0]);
rtn += hex; rtn += hex;
@ -194,7 +194,7 @@ private:
return out; return out;
} }
bool itemMatchesString(VerilatedCovImpItem* itemp, const string& match) { bool itemMatchesString(VerilatedCovImpItem* itemp, const string& match) {
for (int i=0; i<MAX_KEYS; i++) { for (int i=0; i<MAX_KEYS; ++i) {
if (itemp->m_keys[i] != KEY_UNDEF) { if (itemp->m_keys[i] != KEY_UNDEF) {
// We don't compare keys, only values // We don't compare keys, only values
string val = m_indexValues[itemp->m_vals[i]]; string val = m_indexValues[itemp->m_vals[i]];
@ -274,15 +274,15 @@ public:
// Keys -> strings // Keys -> strings
string keys[MAX_KEYS]; string keys[MAX_KEYS];
for (int i=0; i<MAX_KEYS; i++) { for (int i=0; i<MAX_KEYS; ++i) {
if (ckeyps[i] && ckeyps[i][0]) { if (ckeyps[i] && ckeyps[i][0]) {
keys[i] = ckeyps[i]; keys[i] = ckeyps[i];
} }
} }
// Ignore empty keys // Ignore empty keys
for (int i=0; i<MAX_KEYS; i++) { for (int i=0; i<MAX_KEYS; ++i) {
if (keys[i]!="") { if (keys[i]!="") {
for (int j=i+1; j<MAX_KEYS; j++) { for (int j=i+1; j<MAX_KEYS; ++j) {
if (keys[i] == keys[j]) { // Duplicate key. Keep the last one if (keys[i] == keys[j]) { // Duplicate key. Keep the last one
keys[i] = ""; keys[i] = "";
break; break;
@ -292,7 +292,7 @@ public:
} }
// Insert the values // Insert the values
int addKeynum=0; int addKeynum=0;
for (int i=0; i<MAX_KEYS; i++) { for (int i=0; i<MAX_KEYS; ++i) {
const string key = keys[i]; const string key = keys[i];
if (keys[i]!="") { if (keys[i]!="") {
const string val = valps[i]; const string val = valps[i];
@ -334,7 +334,7 @@ public:
string hier; string hier;
bool per_instance = false; bool per_instance = false;
for (int i=0; i<MAX_KEYS; i++) { for (int i=0; i<MAX_KEYS; ++i) {
if (itemp->m_keys[i] != KEY_UNDEF) { if (itemp->m_keys[i] != KEY_UNDEF) {
string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]); string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]);
string val = m_indexValues[itemp->m_vals[i]]; string val = m_indexValues[itemp->m_vals[i]];

4
include/verilated_cov.h
View File

@ -60,9 +60,9 @@ using namespace std;
/// ///
/// vluint32_t m_cases[10]; /// vluint32_t m_cases[10];
/// constructor { /// constructor {
/// for (int i=0; i<10; i++) { m_cases[i]=0; } /// for (int i=0; i<10; ++i) { m_cases[i]=0; }
/// } /// }
/// for (int i=0; i<10; i++) { /// for (int i=0; i<10; ++i) {
/// VL_COVER_INSERT(&m_cases[i], "comment", "Coverage Case", "i", cvtToNumStr(i)); /// VL_COVER_INSERT(&m_cases[i], "comment", "Coverage Case", "i", cvtToNumStr(i));
/// } /// }

10
include/verilated_dpi.h
View File

@ -37,25 +37,25 @@
/// Return svBitVecVal from WData /// Return svBitVecVal from WData
static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, svBitVecVal* lwp) { static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, svBitVecVal* lwp) {
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
for (int i=0; i<words-1; i++) owp[i]=lwp[i]; for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
owp[words-1] = lwp[words-1] & VL_MASK_I(obits); owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
} }
static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) { static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) {
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
for (int i=0; i<words-1; i++) owp[i]=lwp[i]; for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
owp[words-1] = lwp[words-1] & VL_MASK_I(obits); owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
} }
static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, svLogicVecVal* lwp) { static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, svLogicVecVal* lwp) {
// Note we ignore X/Z in svLogicVecVal // Note we ignore X/Z in svLogicVecVal
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
for (int i=0; i<words-1; i++) owp[i]=lwp[i].aval; for (int i=0; i<words-1; ++i) owp[i]=lwp[i].aval;
owp[words-1] = lwp[words-1].aval & VL_MASK_I(obits); owp[words-1] = lwp[words-1].aval & VL_MASK_I(obits);
} }
static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) { static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) {
// Note we don't create X/Z in svLogicVecVal // Note we don't create X/Z in svLogicVecVal
int words = VL_WORDS_I(obits); int words = VL_WORDS_I(obits);
for (int i=0; i<words; i++) owp[i].bval=0; for (int i=0; i<words; ++i) owp[i].bval=0;
for (int i=0; i<words-1; i++) owp[i].aval=lwp[i]; for (int i=0; i<words-1; ++i) owp[i].aval=lwp[i];
owp[words-1].aval = lwp[words-1] & VL_MASK_I(obits); owp[words-1].aval = lwp[words-1] & VL_MASK_I(obits);
} }

2
include/verilated_heavy.h
View File

@ -53,7 +53,7 @@ inline string VL_CONCATN_NNN(const string& lhs, const string& rhs) {
} }
inline string VL_REPLICATEN_NNQ(int,int,int, const string& lhs, IData rep) { inline string VL_REPLICATEN_NNQ(int,int,int, const string& lhs, IData rep) {
string out; out.reserve(lhs.length() * rep); string out; out.reserve(lhs.length() * rep);
for (unsigned times=0; times<rep; times++) out += lhs; for (unsigned times=0; times<rep; ++times) out += lhs;
return out; return out;
} }
inline string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const string& lhs, IData rep) { inline string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const string& lhs, IData rep) {

4
include/verilated_imp.h
View File

@ -97,7 +97,7 @@ public: // But only for verilated*.cpp
} }
static void commandArgsAdd(int argc, const char** argv) { static void commandArgsAdd(int argc, const char** argv) {
if (!s_s.m_argVecLoaded) s_s.m_argVec.clear(); if (!s_s.m_argVecLoaded) s_s.m_argVec.clear();
for (int i=0; i<argc; i++) s_s.m_argVec.push_back(argv[i]); for (int i=0; i<argc; ++i) s_s.m_argVec.push_back(argv[i]);
s_s.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok s_s.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok
} }
static string argPlusMatch(const char* prefixp) { static string argPlusMatch(const char* prefixp) {
@ -238,7 +238,7 @@ public: // But only for verilated*.cpp
// Need to create more space in m_fdps and m_fdFree // Need to create more space in m_fdps and m_fdFree
size_t start = s_s.m_fdps.size(); size_t start = s_s.m_fdps.size();
s_s.m_fdps.resize(start*2); s_s.m_fdps.resize(start*2);
for (size_t i=start; i<start*2; i++) s_s.m_fdFree.push_back((IData)i); for (size_t i=start; i<start*2; ++i) s_s.m_fdFree.push_back((IData)i);
} }
IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back(); IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back();
s_s.m_fdps[idx] = fp; s_s.m_fdps[idx] = fp;

22
include/verilated_vpi.cpp
View File

@ -754,7 +754,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
vl_fatal(__FILE__,__LINE__,"", "vpi_get_value with more than VL_MULS_MAX_WORDS; increase and recompile"); vl_fatal(__FILE__,__LINE__,"", "vpi_get_value with more than VL_MULS_MAX_WORDS; increase and recompile");
} }
WDataInP datap = ((IData*)(vop->varDatap())); WDataInP datap = ((IData*)(vop->varDatap()));
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
out[i].aval = datap[i]; out[i].aval = datap[i];
out[i].bval = 0; out[i].bval = 0;
} }
@ -791,7 +791,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
_VL_VPI_WARNING(__FILE__, __LINE__, "%s: Truncating string value of %s for %s as buffer size (%d, VL_MULS_MAX_WORDS=%d) is less than required (%d)", _VL_VPI_WARNING(__FILE__, __LINE__, "%s: Truncating string value of %s for %s as buffer size (%d, VL_MULS_MAX_WORDS=%d) is less than required (%d)",
VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, bits); VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, bits);
} }
for (i=0; i<bits; i++) { for (i=0; i<bits; ++i) {
char val = (datap[i>>3]>>(i&7))&1; char val = (datap[i>>3]>>(i&7))&1;
outStr[bits-i-1] = val?'1':'0'; outStr[bits-i-1] = val?'1':'0';
} }
@ -821,7 +821,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, chars); VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, chars);
chars = outStrSz; chars = outStrSz;
} }
for (i=0; i<chars; i++) { for (i=0; i<chars; ++i) {
div_t idx = div(i*3, 8); div_t idx = div(i*3, 8);
int val = datap[idx.quot]; int val = datap[idx.quot];
if ((idx.quot+1)<bytes) { if ((idx.quot+1)<bytes) {
@ -882,7 +882,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, chars); VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, chars);
chars = outStrSz; chars = outStrSz;
} }
for (i=0; i<chars; i++) { for (i=0; i<chars; ++i) {
char val = (datap[i>>1]>>((i&1)<<2))&15; char val = (datap[i>>1]>>((i&1)<<2))&15;
static char hex[] = "0123456789abcdef"; static char hex[] = "0123456789abcdef";
if (i==(chars-1)) { if (i==(chars-1)) {
@ -922,7 +922,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, bytes); vop->fullname(), outStrSz, VL_MULS_MAX_WORDS, bytes);
bytes = outStrSz; bytes = outStrSz;
} }
for (i=0; i<bytes; i++) { for (i=0; i<bytes; ++i) {
char val = datap[bytes-i-1]; char val = datap[bytes-i-1];
// other simulators replace [leading?] zero chars with spaces, replicate here. // other simulators replace [leading?] zero chars with spaces, replicate here.
outStr[i] = val?val:' '; outStr[i] = val?val:' ';
@ -1007,7 +1007,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
case VLVT_WDATA: { case VLVT_WDATA: {
int words = VL_WORDS_I(vop->varp()->range().elements()); int words = VL_WORDS_I(vop->varp()->range().elements());
WDataOutP datap = ((IData*)(vop->varDatap())); WDataOutP datap = ((IData*)(vop->varDatap()));
for (int i=0; i<words; i++) { for (int i=0; i<words; ++i) {
datap[i] = value_p->value.vector[i].aval; datap[i] = value_p->value.vector[i].aval;
if (i==(words-1)) { if (i==(words-1)) {
datap[i] &= vop->mask(); datap[i] &= vop->mask();
@ -1037,7 +1037,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
int bits = vop->varp()->range().elements(); int bits = vop->varp()->range().elements();
int len = strlen(value_p->value.str); int len = strlen(value_p->value.str);
CData* datap = ((CData*)(vop->varDatap())); CData* datap = ((CData*)(vop->varDatap()));
for (int i=0; i<bits; i++) { for (int i=0; i<bits; ++i) {
char set = (i < len)?(value_p->value.str[len-i-1]=='1'):0; char set = (i < len)?(value_p->value.str[len-i-1]=='1'):0;
// zero bits 7:1 of byte when assigning to bit 0, else // zero bits 7:1 of byte when assigning to bit 0, else
// or in 1 if bit set // or in 1 if bit set
@ -1067,7 +1067,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
CData* datap = ((CData*)(vop->varDatap())); CData* datap = ((CData*)(vop->varDatap()));
div_t idx; div_t idx;
datap[0] = 0; // reset zero'th byte datap[0] = 0; // reset zero'th byte
for (int i=0; i<chars; i++) { for (int i=0; i<chars; ++i) {
union { union {
char byte[2]; char byte[2];
short half; short half;
@ -1105,7 +1105,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
datap[idx.quot+1] &= vop->mask_byte(idx.quot+1); datap[idx.quot+1] &= vop->mask_byte(idx.quot+1);
} }
// zero off remaining top bytes // zero off remaining top bytes
for (int i=idx.quot+2; i<bytes; i++) { for (int i=idx.quot+2; i<bytes; ++i) {
datap[i] = 0; datap[i] = 0;
} }
return object; return object;
@ -1155,7 +1155,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
val += 2; val += 2;
} }
int len = strlen(val); int len = strlen(val);
for (int i=0; i<chars; i++) { for (int i=0; i<chars; ++i) {
char hex; char hex;
// compute hex digit value // compute hex digit value
if (i < len) { if (i < len) {
@ -1197,7 +1197,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
int bytes = VL_BYTES_I(vop->varp()->range().elements()); int bytes = VL_BYTES_I(vop->varp()->range().elements());
int len = strlen(value_p->value.str); int len = strlen(value_p->value.str);
CData* datap = ((CData*)(vop->varDatap())); CData* datap = ((CData*)(vop->varDatap()));
for (int i=0; i<bytes; i++) { for (int i=0; i<bytes; ++i) {
datap[i] = (i < len)?value_p->value.str[len-i-1]:0; // prepend with 0 values before placing string the least signifcant bytes datap[i] = (i < len)?value_p->value.str[len-i-1]:0; // prepend with 0 values before placing string the least signifcant bytes
} }
return object; return object;