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

Internals: Create dtypeFrom. Merge from dtype. No functional change.

This commit is contained in:
Wilson Snyder 2012-04-29 09:42:17 -04:00
parent a4ddc5b3ac
commit c0da16bfcd
8 changed files with 56 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/V3Ast.h
View File

@ -886,6 +886,7 @@ public:
void numericFrom(AstNode* fromp) { numeric(fromp->numeric()); } void numericFrom(AstNode* fromp) { numeric(fromp->numeric()); }
void numeric(AstNumeric flag) { m_numeric = (int)flag; if (flag.isDouble()) width(64,64); } void numeric(AstNumeric flag) { m_numeric = (int)flag; if (flag.isDouble()) width(64,64); }
AstNumeric numeric() const { return AstNumeric(m_numeric); } AstNumeric numeric() const { return AstNumeric(m_numeric); }
void dtypeFrom(AstNode* fromp) { if (fromp) { widthSignedFrom(fromp); }}
bool isUnsigned() const { return numeric().isUnsigned(); } bool isUnsigned() const { return numeric().isUnsigned(); }
void didWidth(bool flag) { m_didWidth=flag; } void didWidth(bool flag) { m_didWidth=flag; }
bool didWidth() const { return m_didWidth; } bool didWidth() const { return m_didWidth; }
@ -1080,7 +1081,7 @@ struct AstNodeUniop : public AstNodeMath {
// Unary math // Unary math
AstNodeUniop(FileLine* fl, AstNode* lhsp) AstNodeUniop(FileLine* fl, AstNode* lhsp)
: AstNodeMath(fl) { : AstNodeMath(fl) {
if (lhsp) widthSignedFrom(lhsp); dtypeFrom(lhsp);
setOp1p(lhsp); } setOp1p(lhsp); }
ASTNODE_BASE_FUNCS(NodeUniop) ASTNODE_BASE_FUNCS(NodeUniop)
AstNode* lhsp() const { return op1p()->castNode(); } AstNode* lhsp() const { return op1p()->castNode(); }
@ -1160,8 +1161,8 @@ struct AstNodeBiComAsv : public AstNodeBiCom {
struct AstNodeCond : public AstNodeTriop { struct AstNodeCond : public AstNodeTriop {
AstNodeCond(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p) AstNodeCond(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p)
: AstNodeTriop(fl, condp, expr1p, expr2p) { : AstNodeTriop(fl, condp, expr1p, expr2p) {
if (expr1p) widthSignedFrom(expr1p); if (expr1p) dtypeFrom(expr1p);
else if (expr2p) widthSignedFrom(expr2p); else if (expr2p) dtypeFrom(expr2p);
} }
ASTNODE_BASE_FUNCS(NodeCond) ASTNODE_BASE_FUNCS(NodeCond)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) { virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) {
@ -1213,7 +1214,7 @@ struct AstNodeAssign : public AstNodeStmt {
AstNodeAssign(FileLine* fl, AstNode* lhsp, AstNode* rhsp) AstNodeAssign(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
: AstNodeStmt(fl) { : AstNodeStmt(fl) {
setOp1p(rhsp); setOp2p(lhsp); setOp1p(rhsp); setOp2p(lhsp);
if (lhsp) widthSignedFrom(lhsp); dtypeFrom(lhsp);
} }
ASTNODE_BASE_FUNCS(NodeAssign) ASTNODE_BASE_FUNCS(NodeAssign)
virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp)=0; // Clone single node, just get same type back. virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp)=0; // Clone single node, just get same type back.

50
src/V3AstNodes.h
View File

@ -435,7 +435,7 @@ private:
public: public:
AstEnumItemRef(FileLine* fl, AstEnumItem* itemp, AstPackage* packagep) AstEnumItemRef(FileLine* fl, AstEnumItem* itemp, AstPackage* packagep)
: AstNodeMath(fl), m_itemp(itemp), m_packagep(packagep) { : AstNodeMath(fl), m_itemp(itemp), m_packagep(packagep) {
if (m_itemp) widthSignedFrom(m_itemp); dtypeFrom(m_itemp);
} }
ASTNODE_NODE_FUNCS(EnumItemRef, ENUMITEMREF) ASTNODE_NODE_FUNCS(EnumItemRef, ENUMITEMREF)
virtual void dump(ostream& str); virtual void dump(ostream& str);
@ -924,7 +924,7 @@ public:
:AstNode(fl) :AstNode(fl)
, m_scopep(scopep), m_varp(varp) { , m_scopep(scopep), m_varp(varp) {
m_circular = false; m_circular = false;
widthSignedFrom(varp); dtypeFrom(varp);
} }
ASTNODE_NODE_FUNCS(VarScope, VARSCOPE) ASTNODE_NODE_FUNCS(VarScope, VARSCOPE)
virtual void cloneRelink() { if (m_varp && m_varp->clonep()) { virtual void cloneRelink() { if (m_varp && m_varp->clonep()) {
@ -1444,7 +1444,7 @@ struct AstAlwaysPost : public AstNode {
struct AstAssign : public AstNodeAssign { struct AstAssign : public AstNodeAssign {
AstAssign(FileLine* fileline, AstNode* lhsp, AstNode* rhsp) AstAssign(FileLine* fileline, AstNode* lhsp, AstNode* rhsp)
: AstNodeAssign(fileline, lhsp, rhsp) { : AstNodeAssign(fileline, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); dtypeFrom(lhsp);
} }
ASTNODE_NODE_FUNCS(Assign, ASSIGN) ASTNODE_NODE_FUNCS(Assign, ASSIGN)
virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssign(this->fileline(), lhsp, rhsp); } virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssign(this->fileline(), lhsp, rhsp); }
@ -2385,7 +2385,7 @@ public:
AstTraceDecl(FileLine* fl, const string& showname, AstVar* varp) AstTraceDecl(FileLine* fl, const string& showname, AstVar* varp)
: AstNodeStmt(fl) : AstNodeStmt(fl)
, m_showname(showname) { , m_showname(showname) {
widthSignedFrom(varp); dtypeFrom(varp);
m_code = 0; m_code = 0;
m_codeInc = varp->dtypep()->arrayElements() * varp->widthWords(); m_codeInc = varp->dtypep()->arrayElements() * varp->widthWords();
AstBasicDType* bdtypep = varp->basicp(); AstBasicDType* bdtypep = varp->basicp();
@ -2426,7 +2426,7 @@ private:
public: public:
AstTraceInc(FileLine* fl, AstTraceDecl* declp, AstNode* valuep) AstTraceInc(FileLine* fl, AstTraceDecl* declp, AstNode* valuep)
: AstNodeStmt(fl) { : AstNodeStmt(fl) {
widthSignedFrom(declp); dtypeFrom(declp);
m_declp = declp; m_declp = declp;
addNOp2p(valuep); addNOp2p(valuep);
} }
@ -2627,7 +2627,7 @@ struct AstUCFunc : public AstNodeMath {
struct AstNegate : public AstNodeUniop { struct AstNegate : public AstNodeUniop {
AstNegate(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) { AstNegate(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Negate, NEGATE) ASTNODE_NODE_FUNCS(Negate, NEGATE)
virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNegate(lhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNegate(lhs); }
virtual string emitVerilog() { return "%f(- %l)"; } virtual string emitVerilog() { return "%f(- %l)"; }
@ -2707,7 +2707,7 @@ struct AstLogNot : public AstNodeUniop {
}; };
struct AstNot : public AstNodeUniop { struct AstNot : public AstNodeUniop {
AstNot(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) { AstNot(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Not, NOT) ASTNODE_NODE_FUNCS(Not, NOT)
virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNot(lhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNot(lhs); }
virtual string emitVerilog() { return "%f(~ %l)"; } virtual string emitVerilog() { return "%f(~ %l)"; }
@ -2887,7 +2887,7 @@ struct AstCast : public AstNode {
// Cast to appropriate data type - note lhsp is value, to match AstTypedef, AstCCast, etc // Cast to appropriate data type - note lhsp is value, to match AstTypedef, AstCCast, etc
AstCast(FileLine* fl, AstNode* lhsp, AstNodeDType* dtp) : AstNode(fl) { AstCast(FileLine* fl, AstNode* lhsp, AstNodeDType* dtp) : AstNode(fl) {
setOp1p(lhsp); setOp2p(dtp); setOp1p(lhsp); setOp2p(dtp);
if (dtp) { widthSignedFrom(dtp); } dtypeFrom(dtp);
} }
ASTNODE_NODE_FUNCS(Cast, CAST) ASTNODE_NODE_FUNCS(Cast, CAST)
virtual bool hasDType() const { return true; } virtual bool hasDType() const { return true; }
@ -2912,7 +2912,7 @@ public:
} }
} }
AstCCast(FileLine* fl, AstNode* lhsp, AstNode* typeFromp) : AstNodeUniop(fl, lhsp) { AstCCast(FileLine* fl, AstNode* lhsp, AstNode* typeFromp) : AstNodeUniop(fl, lhsp) {
if (typeFromp) { widthSignedFrom(typeFromp); } dtypeFrom(typeFromp);
m_size=width(); m_size=width();
} }
ASTNODE_NODE_FUNCS(CCast, CCAST) ASTNODE_NODE_FUNCS(CCast, CCAST)
@ -3108,7 +3108,7 @@ struct AstLogIff : public AstNodeBiCom {
}; };
struct AstOr : public AstNodeBiComAsv { struct AstOr : public AstNodeBiComAsv {
AstOr(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) { AstOr(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Or, OR) ASTNODE_NODE_FUNCS(Or, OR)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opOr(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opOr(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f| %r)"; } virtual string emitVerilog() { return "%k(%l %f| %r)"; }
@ -3120,7 +3120,7 @@ struct AstOr : public AstNodeBiComAsv {
}; };
struct AstAnd : public AstNodeBiComAsv { struct AstAnd : public AstNodeBiComAsv {
AstAnd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) { AstAnd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(And, AND) ASTNODE_NODE_FUNCS(And, AND)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAnd(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAnd(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f& %r)"; } virtual string emitVerilog() { return "%k(%l %f& %r)"; }
@ -3132,7 +3132,7 @@ struct AstAnd : public AstNodeBiComAsv {
}; };
struct AstXor : public AstNodeBiComAsv { struct AstXor : public AstNodeBiComAsv {
AstXor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) { AstXor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Xor, XOR) ASTNODE_NODE_FUNCS(Xor, XOR)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opXor(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opXor(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f^ %r)"; } virtual string emitVerilog() { return "%k(%l %f^ %r)"; }
@ -3144,7 +3144,7 @@ struct AstXor : public AstNodeBiComAsv {
}; };
struct AstXnor : public AstNodeBiComAsv { struct AstXnor : public AstNodeBiComAsv {
AstXnor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) { AstXnor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Xnor, XNOR) ASTNODE_NODE_FUNCS(Xnor, XNOR)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opXnor(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opXnor(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f^ ~ %r)"; } virtual string emitVerilog() { return "%k(%l %f^ ~ %r)"; }
@ -3407,7 +3407,7 @@ struct AstShiftRS : public AstNodeBiop {
}; };
struct AstAdd : public AstNodeBiComAsv { struct AstAdd : public AstNodeBiComAsv {
AstAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) { AstAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Add, ADD) ASTNODE_NODE_FUNCS(Add, ADD)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAdd(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAdd(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f+ %r)"; } virtual string emitVerilog() { return "%k(%l %f+ %r)"; }
@ -3433,7 +3433,7 @@ struct AstAddD : public AstNodeBiComAsv {
}; };
struct AstSub : public AstNodeBiop { struct AstSub : public AstNodeBiop {
AstSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Sub, SUB) ASTNODE_NODE_FUNCS(Sub, SUB)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opSub(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opSub(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f- %r)"; } virtual string emitVerilog() { return "%k(%l %f- %r)"; }
@ -3459,7 +3459,7 @@ struct AstSubD : public AstNodeBiop {
}; };
struct AstMul : public AstNodeBiComAsv { struct AstMul : public AstNodeBiComAsv {
AstMul(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) { AstMul(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Mul, MUL) ASTNODE_NODE_FUNCS(Mul, MUL)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opMul(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opMul(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f* %r)"; } virtual string emitVerilog() { return "%k(%l %f* %r)"; }
@ -3486,7 +3486,7 @@ struct AstMulD : public AstNodeBiComAsv {
}; };
struct AstMulS : public AstNodeBiComAsv { struct AstMulS : public AstNodeBiComAsv {
AstMulS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) { AstMulS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(MulS, MULS) ASTNODE_NODE_FUNCS(MulS, MULS)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opMulS(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opMulS(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f* %r)"; } virtual string emitVerilog() { return "%k(%l %f* %r)"; }
@ -3500,7 +3500,7 @@ struct AstMulS : public AstNodeBiComAsv {
}; };
struct AstDiv : public AstNodeBiop { struct AstDiv : public AstNodeBiop {
AstDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Div, DIV) ASTNODE_NODE_FUNCS(Div, DIV)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opDiv(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opDiv(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f/ %r)"; } virtual string emitVerilog() { return "%k(%l %f/ %r)"; }
@ -3526,7 +3526,7 @@ struct AstDivD : public AstNodeBiop {
}; };
struct AstDivS : public AstNodeBiop { struct AstDivS : public AstNodeBiop {
AstDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(DivS, DIVS) ASTNODE_NODE_FUNCS(DivS, DIVS)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opDivS(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opDivS(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f/ %r)"; } virtual string emitVerilog() { return "%k(%l %f/ %r)"; }
@ -3539,7 +3539,7 @@ struct AstDivS : public AstNodeBiop {
}; };
struct AstModDiv : public AstNodeBiop { struct AstModDiv : public AstNodeBiop {
AstModDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstModDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(ModDiv, MODDIV) ASTNODE_NODE_FUNCS(ModDiv, MODDIV)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opModDiv(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opModDiv(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f%% %r)"; } virtual string emitVerilog() { return "%k(%l %f%% %r)"; }
@ -3551,7 +3551,7 @@ struct AstModDiv : public AstNodeBiop {
}; };
struct AstModDivS : public AstNodeBiop { struct AstModDivS : public AstNodeBiop {
AstModDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstModDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(ModDivS, MODDIVS) ASTNODE_NODE_FUNCS(ModDivS, MODDIVS)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opModDivS(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opModDivS(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f%% %r)"; } virtual string emitVerilog() { return "%k(%l %f%% %r)"; }
@ -3564,7 +3564,7 @@ struct AstModDivS : public AstNodeBiop {
}; };
struct AstPow : public AstNodeBiop { struct AstPow : public AstNodeBiop {
AstPow(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstPow(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(Pow, POW) ASTNODE_NODE_FUNCS(Pow, POW)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPow(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPow(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f** %r)"; } virtual string emitVerilog() { return "%k(%l %f** %r)"; }
@ -3589,7 +3589,7 @@ struct AstPowD : public AstNodeBiop {
}; };
struct AstPowS : public AstNodeBiop { struct AstPowS : public AstNodeBiop {
AstPowS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstPowS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(PowS, POWS) ASTNODE_NODE_FUNCS(PowS, POWS)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPowS(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPowS(lhs,rhs); }
virtual string emitVerilog() { return "%k(%l %f** %r)"; } virtual string emitVerilog() { return "%k(%l %f** %r)"; }
@ -3680,7 +3680,7 @@ struct AstBufIf1 : public AstNodeBiop {
// lhs is enable, rhs is data to drive // lhs is enable, rhs is data to drive
// Note unlike the Verilog bufif1() UDP, this allows any width; each lhsp bit enables respective rhsp bit // Note unlike the Verilog bufif1() UDP, this allows any width; each lhsp bit enables respective rhsp bit
AstBufIf1(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) { AstBufIf1(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
if (lhsp) widthSignedFrom(lhsp); } dtypeFrom(lhsp); }
ASTNODE_NODE_FUNCS(BufIf1, BUFIF1) ASTNODE_NODE_FUNCS(BufIf1, BUFIF1)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opBufIf1(lhs,rhs); } virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opBufIf1(lhs,rhs); }
virtual string emitVerilog() { return "bufif(%r,%l)"; } virtual string emitVerilog() { return "bufif(%r,%l)"; }
@ -4134,7 +4134,7 @@ public:
AstCMath(FileLine* fl, AstNode* exprsp) AstCMath(FileLine* fl, AstNode* exprsp)
: AstNodeMath(fl), m_cleanOut(true) { : AstNodeMath(fl), m_cleanOut(true) {
addOp1p(exprsp); addOp1p(exprsp);
widthSignedFrom(exprsp); dtypeFrom(exprsp);
} }
AstCMath(FileLine* fl, const string& textStmt, int setwidth, bool cleanOut=true) AstCMath(FileLine* fl, const string& textStmt, int setwidth, bool cleanOut=true)
: AstNodeMath(fl), m_cleanOut(cleanOut) { : AstNodeMath(fl), m_cleanOut(cleanOut) {

26
src/V3Const.cpp
View File

@ -448,7 +448,7 @@ private:
oldp->v3fatalSrc("Already constant??\n"); oldp->v3fatalSrc("Already constant??\n");
} }
AstNode* newp = new AstConst(oldp->fileline(), num); AstNode* newp = new AstConst(oldp->fileline(), num);
newp->widthSignedFrom(oldp); newp->dtypeFrom(oldp);
if (debug()>5) oldp->dumpTree(cout," const_old: "); if (debug()>5) oldp->dumpTree(cout," const_old: ");
if (debug()>5) newp->dumpTree(cout," _new: "); if (debug()>5) newp->dumpTree(cout," _new: ");
oldp->replaceWith(newp); oldp->replaceWith(newp);
@ -483,7 +483,7 @@ private:
AstNode* newp = new AstAnd(nodep->fileline(), AstNode* newp = new AstAnd(nodep->fileline(),
new AstConst(nodep->fileline(), 0), new AstConst(nodep->fileline(), 0),
checkp->unlinkFrBack()); checkp->unlinkFrBack());
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
nodep->replaceWith(newp); nodep->replaceWith(newp);
nodep->deleteTree(); nodep=NULL; nodep->deleteTree(); nodep=NULL;
} }
@ -530,7 +530,7 @@ private:
void replaceWChild(AstNode* nodep, AstNode* childp) { void replaceWChild(AstNode* nodep, AstNode* childp) {
// NODE(..., CHILD(...)) -> CHILD(...) // NODE(..., CHILD(...)) -> CHILD(...)
childp->unlinkFrBackWithNext(); childp->unlinkFrBackWithNext();
childp->widthSignedFrom(nodep); childp->dtypeFrom(nodep);
nodep->replaceWith(childp); nodep->replaceWith(childp);
nodep->deleteTree(); nodep=NULL; nodep->deleteTree(); nodep=NULL;
} }
@ -646,7 +646,7 @@ private:
AstNode* newp = (nodep->castExtendS() AstNode* newp = (nodep->castExtendS()
? (new AstExtendS(nodep->fileline(), arg0p))->castNode() ? (new AstExtendS(nodep->fileline(), arg0p))->castNode()
: (new AstExtend (nodep->fileline(), arg0p))->castNode()); : (new AstExtend (nodep->fileline(), arg0p))->castNode());
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
} }
void replacePowShift (AstNodeBiop* nodep) { // Pow or PowS void replacePowShift (AstNodeBiop* nodep) { // Pow or PowS
@ -655,8 +655,8 @@ private:
AstShiftL* newp = new AstShiftL(nodep->fileline(), AstShiftL* newp = new AstShiftL(nodep->fileline(),
new AstConst(nodep->fileline(), 1), new AstConst(nodep->fileline(), 1),
rhsp); rhsp);
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
newp->lhsp()->widthSignedFrom(nodep); newp->lhsp()->dtypeFrom(nodep);
nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
} }
void replaceMulShift (AstMul* nodep) { // Mul, but not MulS as not simple shift void replaceMulShift (AstMul* nodep) { // Mul, but not MulS as not simple shift
@ -665,7 +665,7 @@ private:
AstNode* opp = nodep->rhsp()->unlinkFrBack(); AstNode* opp = nodep->rhsp()->unlinkFrBack();
AstShiftL* newp = new AstShiftL(nodep->fileline(), AstShiftL* newp = new AstShiftL(nodep->fileline(),
opp, new AstConst(nodep->fileline(), amount)); opp, new AstConst(nodep->fileline(), amount));
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
} }
void replaceDivShift (AstDiv* nodep) { // Mul, but not MulS as not simple shift void replaceDivShift (AstDiv* nodep) { // Mul, but not MulS as not simple shift
@ -674,7 +674,7 @@ private:
AstNode* opp = nodep->lhsp()->unlinkFrBack(); AstNode* opp = nodep->lhsp()->unlinkFrBack();
AstShiftR* newp = new AstShiftR(nodep->fileline(), AstShiftR* newp = new AstShiftR(nodep->fileline(),
opp, new AstConst(nodep->fileline(), amount)); opp, new AstConst(nodep->fileline(), amount));
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
} }
void replaceShiftOp (AstNodeBiop* nodep) { void replaceShiftOp (AstNodeBiop* nodep) {
@ -734,11 +734,11 @@ private:
newp = new AstShiftL(nodep->fileline(), ap, newp = new AstShiftL(nodep->fileline(), ap,
new AstConst(nodep->fileline(), newshift)); new AstConst(nodep->fileline(), newshift));
} }
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
newp = new AstAnd (nodep->fileline(), newp = new AstAnd (nodep->fileline(),
newp, newp,
new AstConst (nodep->fileline(), mask)); new AstConst (nodep->fileline(), mask));
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
//newp->dumpTree(cout, " repShiftShift_new: "); //newp->dumpTree(cout, " repShiftShift_new: ");
newp->accept(*this); // Further reduce, either node may have more reductions. newp->accept(*this); // Further reduce, either node may have more reductions.
@ -1157,7 +1157,7 @@ private:
fromp, fromp,
new AstConst(lsbp->fileline(), lsbp->toUInt() % fromp->width()), new AstConst(lsbp->fileline(), lsbp->toUInt() % fromp->width()),
widthp); widthp);
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
} }
@ -1175,7 +1175,7 @@ private:
bilhsp, lsbp->cloneTree(true), widthp->cloneTree(true))); bilhsp, lsbp->cloneTree(true), widthp->cloneTree(true)));
fromp->rhsp(new AstSel(nodep->fileline(), fromp->rhsp(new AstSel(nodep->fileline(),
birhsp, lsbp, widthp)); birhsp, lsbp, widthp));
fromp->widthSignedFrom(nodep); fromp->dtypeFrom(nodep);
nodep->replaceWith(fromp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(fromp); nodep->deleteTree(); nodep=NULL;
} }
void replaceSelIntoUniop(AstSel* nodep) { void replaceSelIntoUniop(AstSel* nodep) {
@ -1189,7 +1189,7 @@ private:
// //
fromp->lhsp(new AstSel(nodep->fileline(), fromp->lhsp(new AstSel(nodep->fileline(),
bilhsp, lsbp->cloneTree(true), widthp->cloneTree(true))); bilhsp, lsbp->cloneTree(true), widthp->cloneTree(true)));
fromp->widthSignedFrom(nodep); fromp->dtypeFrom(nodep);
nodep->replaceWith(fromp); nodep->deleteTree(); nodep=NULL; nodep->replaceWith(fromp); nodep->deleteTree(); nodep=NULL;
} }

2
src/V3Delayed.cpp
View File

@ -133,7 +133,7 @@ private:
} else { } else {
if (width==0) { if (width==0) {
varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, oldvarscp->varp()); varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, oldvarscp->varp());
varp->widthSignedFrom(oldvarscp); varp->dtypeFrom(oldvarscp);
} else { // Used for vset and dimensions, so can zero init } else { // Used for vset and dimensions, so can zero init
varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, VFlagBitPacked(), width); varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, VFlagBitPacked(), width);
} }

8
src/V3Expand.cpp
View File

@ -320,7 +320,7 @@ private:
AstNode* newp = lhsp; AstNode* newp = lhsp;
if (nodep->isQuad()) { if (nodep->isQuad()) {
if (lhsp->isQuad()) { if (lhsp->isQuad()) {
lhsp->widthSignedFrom(nodep); // Just mark it, else nop lhsp->dtypeFrom(nodep); // Just mark it, else nop
} else if (lhsp->isWide()) { } else if (lhsp->isWide()) {
nodep->v3fatalSrc("extending larger thing into smaller?"); nodep->v3fatalSrc("extending larger thing into smaller?");
} else { } else {
@ -331,7 +331,7 @@ private:
if (lhsp->isQuad() || lhsp->isWide()) { if (lhsp->isQuad() || lhsp->isWide()) {
nodep->v3fatalSrc("extending larger thing into smaller?"); nodep->v3fatalSrc("extending larger thing into smaller?");
} else { } else {
lhsp->widthSignedFrom(nodep); // Just mark it, else nop lhsp->dtypeFrom(nodep); // Just mark it, else nop
} }
} }
replaceWithDelete(nodep,newp); nodep=NULL; replaceWithDelete(nodep,newp); nodep=NULL;
@ -451,11 +451,11 @@ private:
fromp, fromp,
dropCondBound(lsbp), dropCondBound(lsbp),
nodep->width()); nodep->width());
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
if (!nodep->isQuad() && fromp->isQuad()) { if (!nodep->isQuad() && fromp->isQuad()) {
newp = new AstCCast (newp->fileline(), newp, nodep); newp = new AstCCast (newp->fileline(), newp, nodep);
} }
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
replaceWithDelete(nodep,newp); nodep=NULL; replaceWithDelete(nodep,newp); nodep=NULL;
} }
} }

11
src/V3Width.cpp
View File

@ -849,7 +849,7 @@ private:
if (!enump) nodep->v3fatalSrc("EnumItemRef can't deref back to an Enum"); if (!enump) nodep->v3fatalSrc("EnumItemRef can't deref back to an Enum");
enump->iterate(*this,vup); enump->iterate(*this,vup);
} }
nodep->widthSignedFrom(nodep->itemp()); nodep->dtypeFrom(nodep->itemp());
} }
virtual void visit(AstPslClocked* nodep, AstNUser*) { virtual void visit(AstPslClocked* nodep, AstNUser*) {
nodep->propp()->iterateAndNext(*this,WidthVP(1,1,BOTH).p()); nodep->propp()->iterateAndNext(*this,WidthVP(1,1,BOTH).p());
@ -1209,13 +1209,13 @@ private:
if (nodep->lhsp()) { if (nodep->lhsp()) {
// Function hasn't been widthed, so make it so. // Function hasn't been widthed, so make it so.
nodep->iterateChildren(*this,WidthVP(ANYSIZE,0,BOTH).p()); nodep->iterateChildren(*this,WidthVP(ANYSIZE,0,BOTH).p());
nodep->widthSignedFrom(m_funcp->fvarp()); nodep->dtypeFrom(m_funcp->fvarp());
} }
} }
} }
virtual void visit(AstFuncRef* nodep, AstNUser* vup) { virtual void visit(AstFuncRef* nodep, AstNUser* vup) {
visit(nodep->castNodeFTaskRef(), vup); visit(nodep->castNodeFTaskRef(), vup);
nodep->widthSignedFrom(nodep->taskp()); nodep->dtypeFrom(nodep->taskp());
//if (debug()) nodep->dumpTree(cout," FuncOut: "); //if (debug()) nodep->dumpTree(cout," FuncOut: ");
} }
virtual void visit(AstNodeFTaskRef* nodep, AstNUser* vup) { virtual void visit(AstNodeFTaskRef* nodep, AstNUser* vup) {
@ -1593,6 +1593,7 @@ private:
// If errors are off, we need to follow the spec; thus we really need to do the max() // If errors are off, we need to follow the spec; thus we really need to do the max()
// because the rhs could be larger, and we need to have proper editing to get the widths // because the rhs could be larger, and we need to have proper editing to get the widths
// to be the same for our operations. // to be the same for our operations.
//if (debug()>=9) { UINFO(0,"-rus "<<vup->c()<<endl); nodep->dumpTree(cout,"-rusin-"); }
if (vup->c()->prelim()) { // First stage evaluation if (vup->c()->prelim()) { // First stage evaluation
// Determine expression widths only relying on what's in the subops // Determine expression widths only relying on what's in the subops
nodep->lhsp()->iterateAndNext(*this,WidthVP(ANYSIZE,0,PRELIM).p()); nodep->lhsp()->iterateAndNext(*this,WidthVP(ANYSIZE,0,PRELIM).p());
@ -1919,7 +1920,7 @@ private:
} }
UINFO(6," ReplaceWithUOrSVersion: "<<nodep<<" w/ "<<newp<<endl); UINFO(6," ReplaceWithUOrSVersion: "<<nodep<<" w/ "<<newp<<endl);
nodep->replaceWith(newp); nodep->replaceWith(newp);
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
pushDeletep(nodep); nodep=NULL; pushDeletep(nodep); nodep=NULL;
return newp; return newp;
} }
@ -1972,7 +1973,7 @@ private:
} }
UINFO(6," ReplaceWithDVersion: "<<nodep<<" w/ "<<newp<<endl); UINFO(6," ReplaceWithDVersion: "<<nodep<<" w/ "<<newp<<endl);
nodep->replaceWith(newp); nodep->replaceWith(newp);
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
pushDeletep(nodep); nodep=NULL; pushDeletep(nodep); nodep=NULL;
return newp; return newp;
} }

2
src/V3WidthCommit.h
View File

@ -50,7 +50,7 @@ private:
void replaceWithSignedVersion(AstNode* nodep, AstNode* newp) { void replaceWithSignedVersion(AstNode* nodep, AstNode* newp) {
UINFO(6," Replace "<<nodep<<" w/ "<<newp<<endl); UINFO(6," Replace "<<nodep<<" w/ "<<newp<<endl);
nodep->replaceWith(newp); nodep->replaceWith(newp);
newp->widthSignedFrom(nodep); newp->dtypeFrom(nodep);
pushDeletep(nodep); nodep=NULL; pushDeletep(nodep); nodep=NULL;
} }
public: public:

2
src/V3WidthSel.cpp
View File

@ -128,7 +128,7 @@ private:
AstNode* newp = new AstSub(rhsp->fileline(), AstNode* newp = new AstSub(rhsp->fileline(),
new AstConst(rhsp->fileline(), AstConst::Unsized32(), lhs), new AstConst(rhsp->fileline(), AstConst::Unsized32(), lhs),
rhsp); rhsp);
newp->widthSignedFrom(rhsp); // Important as AstSub default is lhs's sign newp->dtypeFrom(rhsp); // Important as AstSub default is lhs's sign
return newp; return newp;
} }