luke/verilator
1
0
Fork 0
mirror of https://github.com/verilator/verilator.git synced 2026-10-06 01:54:01 +02:00
Code Issues Packages Projects Releases Wiki Activity

Internals: Fix spacing of function calls. No functional change.

Browse Source
This commit is contained in:
Wilson Snyder
2018-08-25 09:52:45 -04:00
parent ec538c02d8
commit 75f28fd446
130 changed files with 1519 additions and 1535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/V3Number.cpp
+104 -104
View File
@@ -51,7 +51,7 @@ V3Number::V3Number(VerilogStringLiteral, FileLine* fileline, const string& str)
opCleanThis(true);
}
V3Number::V3Number (FileLine* fileline, const char* sourcep) {
V3Number::V3Number(FileLine* fileline, const char* sourcep) {
init(fileline, 0);
const char* value_startp = sourcep;
for (const char* cp=sourcep; *cp; cp++) {
@@ -823,7 +823,7 @@ uint32_t V3Number::mostSetBitP1() const {
}
//======================================================================
V3Number& V3Number::opBitsNonX (const V3Number& lhs) { // 0/1->1, X/Z->0
V3Number& V3Number::opBitsNonX(const V3Number& lhs) { // 0/1->1, X/Z->0
// op i, L(lhs) bit return
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -831,7 +831,7 @@ V3Number& V3Number::opBitsNonX (const V3Number& lhs) { // 0/1->1, X/Z->0
}
return *this;
}
V3Number& V3Number::opBitsOne (const V3Number& lhs) { // 1->1, 0/X/Z->0
V3Number& V3Number::opBitsOne(const V3Number& lhs) { // 1->1, 0/X/Z->0
// op i, L(lhs) bit return
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -839,7 +839,7 @@ V3Number& V3Number::opBitsOne (const V3Number& lhs) { // 1->1, 0/X/Z->0
}
return *this;
}
V3Number& V3Number::opBitsXZ (const V3Number& lhs) { // 0/1->1, X/Z->0
V3Number& V3Number::opBitsXZ(const V3Number& lhs) { // 0/1->1, X/Z->0
// op i, L(lhs) bit return
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -847,7 +847,7 @@ V3Number& V3Number::opBitsXZ (const V3Number& lhs) { // 0/1->1, X/Z->0
}
return *this;
}
V3Number& V3Number::opBitsZ (const V3Number& lhs) { // 0/1->1, X/Z->0
V3Number& V3Number::opBitsZ(const V3Number& lhs) { // 0/1->1, X/Z->0
// op i, L(lhs) bit return
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -855,7 +855,7 @@ V3Number& V3Number::opBitsZ (const V3Number& lhs) { // 0/1->1, X/Z->0
}
return *this;
}
V3Number& V3Number::opBitsNonZ (const V3Number& lhs) { // 0/1->1, X/Z->0
V3Number& V3Number::opBitsNonZ(const V3Number& lhs) { // 0/1->1, X/Z->0
// op i, L(lhs) bit return
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -867,7 +867,7 @@ V3Number& V3Number::opBitsNonZ (const V3Number& lhs) { // 0/1->1, X/Z->0
//======================================================================
// Operators - Simple per-bit logical ops
V3Number& V3Number::opRedOr (const V3Number& lhs) {
V3Number& V3Number::opRedOr(const V3Number& lhs) {
// op i, 1 bit return
char outc = 0;
for(int bit=0; bit<lhs.width(); bit++) {
@@ -878,7 +878,7 @@ V3Number& V3Number::opRedOr (const V3Number& lhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opRedAnd (const V3Number& lhs) {
V3Number& V3Number::opRedAnd(const V3Number& lhs) {
// op i, 1 bit return
char outc = 1;
for(int bit=0; bit<lhs.width(); bit++) {
@@ -889,7 +889,7 @@ V3Number& V3Number::opRedAnd (const V3Number& lhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opRedXor (const V3Number& lhs) {
V3Number& V3Number::opRedXor(const V3Number& lhs) {
// op i, 1 bit return
char outc = 0;
for(int bit=0; bit<lhs.width(); bit++) {
@@ -900,7 +900,7 @@ V3Number& V3Number::opRedXor (const V3Number& lhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opRedXnor (const V3Number& lhs) {
V3Number& V3Number::opRedXnor(const V3Number& lhs) {
// op i, 1 bit return
char outc = 1;
for(int bit=0; bit<lhs.width(); bit++) {
@@ -911,25 +911,25 @@ V3Number& V3Number::opRedXnor (const V3Number& lhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opCountOnes (const V3Number& lhs) {
V3Number& V3Number::opCountOnes(const V3Number& lhs) {
if (lhs.isFourState()) return setAllBitsX();
setZero();
m_value[0] = lhs.countOnes();
opCleanThis();
return *this;
}
V3Number& V3Number::opIsUnknown (const V3Number& lhs) {
V3Number& V3Number::opIsUnknown(const V3Number& lhs) {
return setSingleBits(lhs.isUnknown());
}
V3Number& V3Number::opOneHot (const V3Number& lhs) {
V3Number& V3Number::opOneHot(const V3Number& lhs) {
if (lhs.isFourState()) return setAllBitsX();
return setSingleBits(lhs.countOnes()==1);
}
V3Number& V3Number::opOneHot0 (const V3Number& lhs) {
V3Number& V3Number::opOneHot0(const V3Number& lhs) {
if (lhs.isFourState()) return setAllBitsX();
return setSingleBits(lhs.countOnes()<=1);
}
V3Number& V3Number::opCLog2 (const V3Number& lhs) {
V3Number& V3Number::opCLog2(const V3Number& lhs) {
if (lhs.isFourState()) return setAllBitsX();
// IE if 4, this algorithm didn't pre-subtract 1, so we need to post-correct now
int adjust = (lhs.countOnes()==1) ? 0 : 1;
@@ -943,7 +943,7 @@ V3Number& V3Number::opCLog2 (const V3Number& lhs) {
return *this;
}
V3Number& V3Number::opLogNot (const V3Number& lhs) {
V3Number& V3Number::opLogNot(const V3Number& lhs) {
// op i, 1 bit return
char outc = 1;
for(int bit=0; bit<lhs.width(); bit++) {
@@ -955,7 +955,7 @@ V3Number& V3Number::opLogNot (const V3Number& lhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opNot (const V3Number& lhs) {
V3Number& V3Number::opNot(const V3Number& lhs) {
// op i, L(lhs) bit return
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -965,7 +965,7 @@ V3Number& V3Number::opNot (const V3Number& lhs) {
return *this;
}
V3Number& V3Number::opAnd (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opAnd(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, careful need to X/Z extend.
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -976,7 +976,7 @@ V3Number& V3Number::opAnd (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opOr (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opOr(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, careful need to X/Z extend.
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -987,13 +987,13 @@ V3Number& V3Number::opOr (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opChangeXor (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opChangeXor(const V3Number& lhs, const V3Number& rhs) {
// 32 bit result
opEq(lhs,rhs);
return *this;
}
V3Number& V3Number::opXor (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opXor(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, careful need to X/Z extend.
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -1005,7 +1005,7 @@ V3Number& V3Number::opXor (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opXnor (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opXnor(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, careful need to X/Z extend.
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -1017,7 +1017,7 @@ V3Number& V3Number::opXnor (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opConcat (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opConcat(const V3Number& lhs, const V3Number& rhs) {
setZero();
// See also error in V3Width
if (!lhs.sized() || !rhs.sized()) {
@@ -1035,19 +1035,19 @@ V3Number& V3Number::opConcat (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opLenN (const V3Number& lhs) {
V3Number& V3Number::opLenN(const V3Number& lhs) {
setQuad(lhs.toString().length());
return *this;
}
V3Number& V3Number::opRepl (const V3Number& lhs, const V3Number& rhs) { // rhs is # of times to replicate
V3Number& V3Number::opRepl(const V3Number& lhs, const V3Number& rhs) { // rhs is # of times to replicate
// Hopefully the using routine has a error check too.
// See also error in V3Width
if (!lhs.sized()) m_fileline->v3warn(WIDTHCONCAT,"Unsized numbers/parameters not allowed in replications.");
return opRepl(lhs, rhs.toUInt());
}
V3Number& V3Number::opRepl (const V3Number& lhs, uint32_t rhsval) { // rhs is # of times to replicate
V3Number& V3Number::opRepl(const V3Number& lhs, uint32_t rhsval) { // rhs is # of times to replicate
// i op repl, L(i)*value(rhs) bit return
setZero();
if (rhsval>8192) m_fileline->v3warn(WIDTHCONCAT,"More than a 8k bit replication is probably wrong: "<<rhsval);
@@ -1061,7 +1061,7 @@ V3Number& V3Number::opRepl (const V3Number& lhs, uint32_t rhsval) { // rhs is #
return *this;
}
V3Number& V3Number::opStreamL (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opStreamL(const V3Number& lhs, const V3Number& rhs) {
setZero();
// See also error in V3Width
if (!lhs.sized()) {
@@ -1078,7 +1078,7 @@ V3Number& V3Number::opStreamL (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opLogAnd (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLogAnd(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation
char loutc = 0;
char routc = 0;
@@ -1096,7 +1096,7 @@ V3Number& V3Number::opLogAnd (const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opLogOr (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLogOr(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
char outc = 0;
for(int bit=0; bit<lhs.width(); bit++) {
@@ -1111,19 +1111,19 @@ last:
return setSingleBits(outc);
}
V3Number& V3Number::opLogIf (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLogIf(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to
// X/Z extend. Use opLogNot and opLogOr to do this for us.
return opLogOr(opLogNot(lhs), rhs);
}
V3Number& V3Number::opLogIff (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLogIff(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to
// X/Z extend. Use opLogNot and opLogXor to do this for us.
return opLogNot(opXor(lhs, rhs));
}
V3Number& V3Number::opEq (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opEq(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
char outc = 1;
for (int bit=0; bit < std::max(lhs.width(),rhs.width()); bit++) {
@@ -1136,7 +1136,7 @@ last:
return setSingleBits(outc);
}
V3Number& V3Number::opNeq (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opNeq(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
char outc = 0;
for (int bit=0; bit < std::max(lhs.width(),rhs.width()); bit++) {
@@ -1149,7 +1149,7 @@ last:
return setSingleBits(outc);
}
bool V3Number::isCaseEq (const V3Number& rhs) const {
bool V3Number::isCaseEq(const V3Number& rhs) const {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
if (this->width() != rhs.width()) return false;
for (int bit=0; bit < std::max(this->width(),rhs.width()); bit++) {
@@ -1158,11 +1158,11 @@ bool V3Number::isCaseEq (const V3Number& rhs) const {
return true;
}
V3Number& V3Number::opCaseEq (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opCaseEq(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.isCaseEq(rhs) ? 1:0);
}
V3Number& V3Number::opCaseNeq (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opCaseNeq(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
char outc = 0;
for (int bit=0; bit < std::max(lhs.width(),rhs.width()); bit++) {
@@ -1172,7 +1172,7 @@ last:
return setSingleBits(outc);
}
V3Number& V3Number::opWildEq (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opWildEq(const V3Number& lhs, const V3Number& rhs) {
char outc = 1;
for (int bit=0; bit < std::max(lhs.width(),rhs.width()); bit++) {
if (!rhs.bitIsXZ(bit)
@@ -1183,7 +1183,7 @@ last:
return setSingleBits(outc);
}
V3Number& V3Number::opWildNeq (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opWildNeq(const V3Number& lhs, const V3Number& rhs) {
char outc = 0;
for (int bit=0; bit < std::max(lhs.width(),rhs.width()); bit++) {
if (!rhs.bitIsXZ(bit)
@@ -1194,7 +1194,7 @@ last:
return setSingleBits(outc);
}
V3Number& V3Number::opGt (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGt(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
char outc = 0;
for (int bit=0; bit < std::max(lhs.width(),rhs.width()); bit++) {
@@ -1206,7 +1206,7 @@ V3Number& V3Number::opGt (const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opGtS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGtS(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
char outc = 0;
{
@@ -1228,34 +1228,34 @@ V3Number& V3Number::opGtS (const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(outc);
}
V3Number& V3Number::opGte (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGte(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
V3Number& eq = opEq (lhs,rhs);
V3Number& eq = opEq(lhs,rhs);
if (eq.isNeqZero()) return eq; // Return true
return opGt (lhs,rhs);
return opGt(lhs,rhs);
}
V3Number& V3Number::opGteS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGteS(const V3Number& lhs, const V3Number& rhs) {
// i op j, 1 bit return, max(L(lhs),L(rhs)) calculation, careful need to X/Z extend.
V3Number& eq = opEq (lhs,rhs);
V3Number& eq = opEq(lhs,rhs);
if (eq.isNeqZero()) return eq; // Return true
return opGtS (lhs,rhs);
return opGtS(lhs,rhs);
}
V3Number& V3Number::opLt (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLt(const V3Number& lhs, const V3Number& rhs) {
return opGt(rhs,lhs);
}
V3Number& V3Number::opLte (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLte(const V3Number& lhs, const V3Number& rhs) {
return opGte(rhs,lhs);
}
V3Number& V3Number::opLtS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLtS(const V3Number& lhs, const V3Number& rhs) {
return opGtS(rhs,lhs);
}
V3Number& V3Number::opLteS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLteS(const V3Number& lhs, const V3Number& rhs) {
return opGteS(rhs,lhs);
}
V3Number& V3Number::opRotR (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opRotR(const V3Number& lhs, const V3Number& rhs) {
// L(lhs) bit return
if (rhs.isFourState()) return setAllBitsX();
setZero();
@@ -1266,7 +1266,7 @@ V3Number& V3Number::opRotR (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opRotL (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opRotL(const V3Number& lhs, const V3Number& rhs) {
// L(lhs) bit return
if (rhs.isFourState()) return setAllBitsX();
setZero();
@@ -1279,7 +1279,7 @@ V3Number& V3Number::opRotL (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opShiftR (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opShiftR(const V3Number& lhs, const V3Number& rhs) {
// L(lhs) bit return
if (rhs.isFourState()) return setAllBitsX();
setZero();
@@ -1295,7 +1295,7 @@ V3Number& V3Number::opShiftR (const V3Number& lhs, const V3Number& rhs) {
return *this;
}
V3Number& V3Number::opShiftRS (const V3Number& lhs, const V3Number& rhs, uint32_t lbits) {
V3Number& V3Number::opShiftRS(const V3Number& lhs, const V3Number& rhs, uint32_t lbits) {
// L(lhs) bit return
// The spec says a unsigned >>> still acts as a normal >>.
// We presume it is signed; as that's V3Width's job to convert to opShiftR
@@ -1321,7 +1321,7 @@ V3Number& V3Number::opShiftRS (const V3Number& lhs, const V3Number& rhs, uint32_
return *this;
}
V3Number& V3Number::opShiftL (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opShiftL(const V3Number& lhs, const V3Number& rhs) {
// L(lhs) bit return
if (rhs.isFourState()) return setAllBitsX();
setZero();
@@ -1340,7 +1340,7 @@ V3Number& V3Number::opShiftL (const V3Number& lhs, const V3Number& rhs) {
//======================================================================
// Ops - Arithmetic
V3Number& V3Number::opAbsS (const V3Number& lhs) {
V3Number& V3Number::opAbsS(const V3Number& lhs) {
// op i, L(lhs) bit return
if (lhs.isFourState()) return setAllBitsX();
if (lhs.isNegative()) {
@@ -1349,7 +1349,7 @@ V3Number& V3Number::opAbsS (const V3Number& lhs) {
return opAssign(lhs);
}
}
V3Number& V3Number::opNegate (const V3Number& lhs) {
V3Number& V3Number::opNegate(const V3Number& lhs) {
// op i, L(lhs) bit return
if (lhs.isFourState()) return setAllBitsX();
V3Number notlhs (lhs.m_fileline, width());
@@ -1358,7 +1358,7 @@ V3Number& V3Number::opNegate (const V3Number& lhs) {
opAdd(notlhs,one);
return *this;
}
V3Number& V3Number::opAdd (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opAdd(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, if any 4-state, 4-state return
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
setZero();
@@ -1373,14 +1373,14 @@ V3Number& V3Number::opAdd (const V3Number& lhs, const V3Number& rhs) {
}
return *this;
}
V3Number& V3Number::opSub (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opSub(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, if any 4-state, 4-state return
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
V3Number negrhs (rhs.m_fileline, rhs.width());
negrhs.opNegate(rhs);
return opAdd(lhs, negrhs);
}
V3Number& V3Number::opMul (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opMul(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, if any 4-state, 4-state return
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
setZero();
@@ -1402,7 +1402,7 @@ V3Number& V3Number::opMul (const V3Number& lhs, const V3Number& rhs) {
}
return *this;
}
V3Number& V3Number::opMulS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opMulS(const V3Number& lhs, const V3Number& rhs) {
// Signed multiply
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
V3Number lhsNoSign = lhs; if (lhs.isNegative()) lhsNoSign.opNegate(lhs);
@@ -1416,7 +1416,7 @@ V3Number& V3Number::opMulS (const V3Number& lhs, const V3Number& rhs) {
}
return *this;
}
V3Number& V3Number::opDiv (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opDiv(const V3Number& lhs, const V3Number& rhs) {
UINFO(9, "opdiv "<<lhs<<" "<<rhs<<endl);
// i op j, max(L(lhs),L(rhs)) bit return, if any 4-state, 4-state return
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
@@ -1429,7 +1429,7 @@ V3Number& V3Number::opDiv (const V3Number& lhs, const V3Number& rhs) {
return opModDivGuts(lhs,rhs,false);
}
}
V3Number& V3Number::opDivS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opDivS(const V3Number& lhs, const V3Number& rhs) {
// Signed divide
//UINFO(9, ">>divs-start "<<lhs<<" "<<rhs<<endl);
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
@@ -1447,7 +1447,7 @@ V3Number& V3Number::opDivS (const V3Number& lhs, const V3Number& rhs) {
UINFO(9, " <divs-out "<<lhs<<" "<<rhs<<" ="<<*this<<endl);
return *this;
}
V3Number& V3Number::opModDiv (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opModDiv(const V3Number& lhs, const V3Number& rhs) {
// i op j, max(L(lhs),L(rhs)) bit return, if any 4-state, 4-state return
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
if (rhs.isEqZero()) return setAllBitsXRemoved();
@@ -1459,7 +1459,7 @@ V3Number& V3Number::opModDiv (const V3Number& lhs, const V3Number& rhs) {
return opModDivGuts(lhs,rhs,true);
}
}
V3Number& V3Number::opModDivS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opModDivS(const V3Number& lhs, const V3Number& rhs) {
// Signed moddiv
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
if (rhs.isEqZero()) return setAllBitsXRemoved();
@@ -1592,7 +1592,7 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
}
}
V3Number& V3Number::opPow (const V3Number& lhs, const V3Number& rhs, bool lsign, bool rsign) {
V3Number& V3Number::opPow(const V3Number& lhs, const V3Number& rhs, bool lsign, bool rsign) {
// L(i) bit return, if any 4-state, 4-state return
if (lhs.isFourState() || rhs.isFourState()) return setAllBitsX();
if (rhs.isEqZero()) return setQuad(1); // Overrides lhs 0 -> return 0
@@ -1623,17 +1623,17 @@ V3Number& V3Number::opPow (const V3Number& lhs, const V3Number& rhs, bool lsign,
}
return *this;
}
V3Number& V3Number::opPowSU (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opPowSU(const V3Number& lhs, const V3Number& rhs) {
return opPow(lhs,rhs,true,false);
}
V3Number& V3Number::opPowSS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opPowSS(const V3Number& lhs, const V3Number& rhs) {
return opPow(lhs,rhs,true,true);
}
V3Number& V3Number::opPowUS (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opPowUS(const V3Number& lhs, const V3Number& rhs) {
return opPow(lhs,rhs,false,true);
}
V3Number& V3Number::opBufIf1 (const V3Number& ens, const V3Number& if1s) {
V3Number& V3Number::opBufIf1(const V3Number& ens, const V3Number& if1s) {
setZero();
for(int bit=0; bit<this->width(); bit++) {
if (ens.bitIs1(bit)) { setBit(bit, if1s.bitIs(bit)); }
@@ -1642,7 +1642,7 @@ V3Number& V3Number::opBufIf1 (const V3Number& ens, const V3Number& if1s) {
return *this;
}
V3Number& V3Number::opAssign (const V3Number& lhs) {
V3Number& V3Number::opAssign(const V3Number& lhs) {
// Note may be a width change during the assign
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -1651,7 +1651,7 @@ V3Number& V3Number::opAssign (const V3Number& lhs) {
return *this;
}
V3Number& V3Number::opExtendS (const V3Number& lhs, uint32_t lbits) {
V3Number& V3Number::opExtendS(const V3Number& lhs, uint32_t lbits) {
// Note may be a width change during the sign extension
setZero();
for(int bit=0; bit<this->width(); bit++) {
@@ -1660,7 +1660,7 @@ V3Number& V3Number::opExtendS (const V3Number& lhs, uint32_t lbits) {
return *this;
}
V3Number& V3Number::opClean (const V3Number& lhs, uint32_t bits) {
V3Number& V3Number::opClean(const V3Number& lhs, uint32_t bits) {
return opSel(lhs, bits-1, 0);
}
@@ -1676,12 +1676,12 @@ void V3Number::opCleanThis(bool warnOnTruncation) {
m_valueX[words()-1] = newValueXMsb;
}
V3Number& V3Number::opSel (const V3Number& lhs, const V3Number& msb, const V3Number& lsb) {
V3Number& V3Number::opSel(const V3Number& lhs, const V3Number& msb, const V3Number& lsb) {
if (lsb.isFourState() || msb.isFourState()) return setAllBitsX();
return opSel(lhs, msb.toUInt(), lsb.toUInt());
}
V3Number& V3Number::opSel (const V3Number& lhs, uint32_t msbval, uint32_t lsbval) {
V3Number& V3Number::opSel(const V3Number& lhs, uint32_t msbval, uint32_t lsbval) {
setZero();
int ibit=lsbval;
for(int bit=0; bit<this->width(); bit++) {
@@ -1697,11 +1697,11 @@ V3Number& V3Number::opSel (const V3Number& lhs, uint32_t msbval, uint32_t lsbval
return *this;
}
V3Number& V3Number::opSelInto (const V3Number& lhs, const V3Number& lsb, int width) {
V3Number& V3Number::opSelInto(const V3Number& lhs, const V3Number& lsb, int width) {
return opSelInto(lhs, lsb.toSInt(), width);
}
V3Number& V3Number::opSelInto (const V3Number& lhs, int lsbval, int width) {
V3Number& V3Number::opSelInto(const V3Number& lhs, int lsbval, int width) {
// this[lsbval+width-1 : lsbval] = lhs; Other bits of this are not affected
int ibit=0;
for(int bit=lsbval; bit<lsbval+width; bit++) {
@@ -1715,7 +1715,7 @@ V3Number& V3Number::opSelInto (const V3Number& lhs, int lsbval, int width) {
return *this;
}
V3Number& V3Number::opCond (const V3Number& lhs, const V3Number& if1s, const V3Number& if0s) {
V3Number& V3Number::opCond(const V3Number& lhs, const V3Number& if1s, const V3Number& if0s) {
V3Number lhstrue (lhs.m_fileline); lhstrue.opRedOr(lhs);
if (lhstrue.bitIs0(0)) {
this->opAssign(if0s);
@@ -1737,20 +1737,20 @@ V3Number& V3Number::opCond (const V3Number& lhs, const V3Number& if1s, const V3
//======================================================================
// Ops - Floating point
V3Number& V3Number::opIToRD (const V3Number& lhs) {
V3Number& V3Number::opIToRD(const V3Number& lhs) {
return setDouble(lhs.toSInt());
}
V3Number& V3Number::opRToIS (const V3Number& lhs) {
V3Number& V3Number::opRToIS(const V3Number& lhs) {
double v = VL_TRUNC(lhs.toDouble());
vlsint32_t i = (vlsint32_t)v; // C converts from double to vlsint32
return setLongS(i);
}
V3Number& V3Number::opRToIRoundS (const V3Number& lhs) {
V3Number& V3Number::opRToIRoundS(const V3Number& lhs) {
double v = VL_ROUND(lhs.toDouble());
vlsint32_t i = (vlsint32_t)v; // C converts from double to vlsint32
return setLongS(i);
}
V3Number& V3Number::opRealToBits (const V3Number& lhs) {
V3Number& V3Number::opRealToBits(const V3Number& lhs) {
// Conveniently our internal format is identical so we can copy bits...
if (lhs.width()!=64 || this->width()!=64) {
m_fileline->v3fatalSrc("Real operation on wrong sized number");
@@ -1759,7 +1759,7 @@ V3Number& V3Number::opRealToBits (const V3Number& lhs) {
m_double = false;
return *this;
}
V3Number& V3Number::opBitsToRealD (const V3Number& lhs) {
V3Number& V3Number::opBitsToRealD(const V3Number& lhs) {
// Conveniently our internal format is identical so we can copy bits...
if (lhs.width()!=64 || this->width()!=64) {
m_fileline->v3fatalSrc("Real operation on wrong sized number");
@@ -1768,78 +1768,78 @@ V3Number& V3Number::opBitsToRealD (const V3Number& lhs) {
m_double = true;
return *this;
}
V3Number& V3Number::opNegateD (const V3Number& lhs) {
V3Number& V3Number::opNegateD(const V3Number& lhs) {
return setDouble(- lhs.toDouble());
}
V3Number& V3Number::opAddD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opAddD(const V3Number& lhs, const V3Number& rhs) {
return setDouble(lhs.toDouble() + rhs.toDouble());
}
V3Number& V3Number::opSubD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opSubD(const V3Number& lhs, const V3Number& rhs) {
return setDouble(lhs.toDouble() - rhs.toDouble());
}
V3Number& V3Number::opMulD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opMulD(const V3Number& lhs, const V3Number& rhs) {
return setDouble(lhs.toDouble() * rhs.toDouble());
}
V3Number& V3Number::opDivD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opDivD(const V3Number& lhs, const V3Number& rhs) {
// On exceptions, we just generate 'inf' through floating point
// IEEE says it's implementation defined what happens
return setDouble(lhs.toDouble() / rhs.toDouble());
}
V3Number& V3Number::opPowD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opPowD(const V3Number& lhs, const V3Number& rhs) {
// On exceptions, we just generate 'inf' through floating point
// IEEE says it's implementation defined what happens
return setDouble(pow(lhs.toDouble(), rhs.toDouble()));
}
V3Number& V3Number::opEqD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opEqD(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toDouble() == rhs.toDouble());
}
V3Number& V3Number::opNeqD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opNeqD(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toDouble() != rhs.toDouble());
}
V3Number& V3Number::opGtD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGtD(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toDouble() > rhs.toDouble());
}
V3Number& V3Number::opGteD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGteD(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toDouble() >= rhs.toDouble());
}
V3Number& V3Number::opLtD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLtD(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toDouble() < rhs.toDouble());
}
V3Number& V3Number::opLteD (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLteD(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toDouble() <= rhs.toDouble());
}
//======================================================================
// Ops - String
V3Number& V3Number::opConcatN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opConcatN(const V3Number& lhs, const V3Number& rhs) {
return setString(lhs.toString() + rhs.toString());
}
V3Number& V3Number::opReplN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opReplN(const V3Number& lhs, const V3Number& rhs) {
return opReplN(lhs, rhs.toUInt());
}
V3Number& V3Number::opReplN (const V3Number& lhs, uint32_t rhsval) {
V3Number& V3Number::opReplN(const V3Number& lhs, uint32_t rhsval) {
string out; out.reserve(lhs.toString().length() * rhsval);
for (unsigned times=0; times<rhsval; times++) {
out += lhs.toString();
}
return setString(out);
}
V3Number& V3Number::opEqN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opEqN(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toString() == rhs.toString());
}
V3Number& V3Number::opNeqN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opNeqN(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toString() != rhs.toString());
}
V3Number& V3Number::opGtN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGtN(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toString() > rhs.toString());
}
V3Number& V3Number::opGteN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opGteN(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toString() >= rhs.toString());
}
V3Number& V3Number::opLtN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLtN(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toString() < rhs.toString());
}
V3Number& V3Number::opLteN (const V3Number& lhs, const V3Number& rhs) {
V3Number& V3Number::opLteN(const V3Number& lhs, const V3Number& rhs) {
return setSingleBits(lhs.toString() <= rhs.toString());
}