forked from github/verilator
ca4e3c1737
git-svn-id: file://localhost/svn/verilator/trunk/verilator@797 77ca24e4-aefa-0310-84f0-b9a241c72d87
455 lines
15 KiB
C++
455 lines
15 KiB
C++
// $Id$
|
||
//*************************************************************************
|
||
// DESCRIPTION: Verilator: Lifelicate variable assignment elimination
|
||
//
|
||
// Code available from: http://www.veripool.com/verilator
|
||
//
|
||
// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
|
||
//
|
||
//*************************************************************************
|
||
//
|
||
// Copyright 2003-2006 by Wilson Snyder. This program is free software; you can
|
||
// redistribute it and/or modify it under the terms of either the GNU
|
||
// General Public License or the Perl Artistic License.
|
||
//
|
||
// Verilator is distributed in the hope that it will be useful,
|
||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
// GNU General Public License for more details.
|
||
//
|
||
//*************************************************************************
|
||
// LIFE TRANSFORMATIONS:
|
||
// Build control-flow graph with assignments and var usages
|
||
// All modules:
|
||
// ASSIGN(x,...), ASSIGN(x,...) => delete first one
|
||
// We also track across if statements:
|
||
// ASSIGN(X,...) IF( ..., ASSIGN(X,...), ASSIGN(X,...)) => deletes first
|
||
// We don't do the opposite yet though (remove assigns in if followed by outside if)
|
||
//
|
||
//*************************************************************************
|
||
|
||
#include "config.h"
|
||
#include <stdio.h>
|
||
#include <stdarg.h>
|
||
#include <unistd.h>
|
||
#include <map>
|
||
|
||
#include "V3Global.h"
|
||
#include "V3Life.h"
|
||
#include "V3Stats.h"
|
||
#include "V3Ast.h"
|
||
#include "V3Const.h"
|
||
|
||
//######################################################################
|
||
// Structure for global state
|
||
|
||
class LifeState {
|
||
// STATE
|
||
public:
|
||
V3Double0 m_statAssnDel; // Statistic tracking
|
||
V3Double0 m_statAssnCon; // Statistic tracking
|
||
|
||
public:
|
||
LifeState() {}
|
||
~LifeState() {
|
||
V3Stats::addStat("Optimizations, Lifetime assign deletions", m_statAssnDel);
|
||
V3Stats::addStat("Optimizations, Lifetime constant prop", m_statAssnCon);
|
||
}
|
||
};
|
||
|
||
//######################################################################
|
||
// Structure for each variable encountered
|
||
|
||
class LifeVarEntry {
|
||
AstNodeAssign* m_assignp; // Last assignment to this varscope, NULL if no longer relevant
|
||
AstConst* m_constp; // Known constant value
|
||
bool m_setBeforeUse; // First access was a set (and thus block above may have a set that can be deleted
|
||
bool m_everSet; // Was ever assigned (and thus above block may not preserve constant propagation)
|
||
|
||
inline void init (bool setBeforeUse) {
|
||
m_assignp = NULL;
|
||
m_constp = NULL;
|
||
m_setBeforeUse = setBeforeUse;
|
||
m_everSet = false;
|
||
}
|
||
public:
|
||
class SIMPLEASSIGN {};
|
||
class COMPLEXASSIGN {};
|
||
class CONSUMED {};
|
||
|
||
LifeVarEntry(SIMPLEASSIGN, AstNodeAssign* assp) {
|
||
init(true); simpleAssign(assp);
|
||
}
|
||
LifeVarEntry(COMPLEXASSIGN) {
|
||
init(false); complexAssign();
|
||
}
|
||
LifeVarEntry(CONSUMED) {
|
||
init(false); consumed();
|
||
}
|
||
~LifeVarEntry() {}
|
||
inline void simpleAssign(AstNodeAssign* assp) { // New simple A=.... assignment
|
||
m_assignp = assp;
|
||
m_constp = NULL;
|
||
m_everSet = true;
|
||
if (assp->rhsp()->castConst()) m_constp = assp->rhsp()->castConst();
|
||
}
|
||
inline void complexAssign() { // A[x]=... or some complicated assignment
|
||
m_assignp = NULL;
|
||
m_constp = NULL;
|
||
m_everSet = true;
|
||
}
|
||
inline void consumed() { // Rvalue read of A
|
||
m_assignp = NULL;
|
||
}
|
||
AstNodeAssign* assignp() const { return m_assignp; }
|
||
AstConst* constNodep() const { return m_constp; }
|
||
bool setBeforeUse() const { return m_setBeforeUse; }
|
||
bool everSet() const { return m_everSet; }
|
||
};
|
||
|
||
//######################################################################
|
||
// Structure for all variables under a given meta-basic block
|
||
|
||
class LifeBlock {
|
||
// NODE STATE
|
||
// Cleared each AstIf:
|
||
// AstVarScope::user() -> int. Used in combining to detect duplicates
|
||
|
||
// LIFE MAP
|
||
// For each basic block, we'll make a new map of what variables that if/else is changing
|
||
typedef std::map<AstVarScope*, LifeVarEntry> LifeMap;
|
||
LifeMap m_map; // Current active lifetime map for current scope
|
||
LifeBlock* m_aboveLifep; // Upper life, or NULL
|
||
LifeState* m_statep; // Current global state
|
||
|
||
public:
|
||
LifeBlock(LifeBlock* aboveLifep, LifeState* statep) {
|
||
m_aboveLifep = aboveLifep; // Null if top
|
||
m_statep = statep;
|
||
}
|
||
~LifeBlock() {}
|
||
// METHODS
|
||
void checkRemoveAssign(const LifeMap::iterator& it) {
|
||
AstVar* varp = it->first->varp();
|
||
LifeVarEntry* entp = &(it->second);
|
||
if (!varp->isSigPublic()) {
|
||
// Rather then track what sigs AstUCFunc/AstUCStmt may change,
|
||
// we just don't optimize any public sigs
|
||
// Check the var entry, and remove if appropriate
|
||
if (AstNode* oldassp = entp->assignp()) {
|
||
UINFO(7," PREV: "<<oldassp<<endl);
|
||
// Redundant assignment, in same level block
|
||
if (debug()>4) oldassp->dumpTree(cout, " REMOVE/SAMEBLK ");
|
||
entp->complexAssign();
|
||
oldassp->unlinkFrBack()->deleteTree(); oldassp=NULL;
|
||
m_statep->m_statAssnDel++;
|
||
}
|
||
}
|
||
}
|
||
void simpleAssign(AstVarScope* nodep, AstNodeAssign* assp) {
|
||
// Do we have a old assignment we can nuke?
|
||
UINFO(4," ASSIGNof: "<<nodep<<endl);
|
||
UINFO(7," new: "<<assp<<endl);
|
||
LifeMap::iterator it = m_map.find(nodep);
|
||
if (it != m_map.end()) {
|
||
checkRemoveAssign(it);
|
||
it->second.simpleAssign(assp);
|
||
} else {
|
||
m_map.insert(make_pair(nodep,LifeVarEntry(LifeVarEntry::SIMPLEASSIGN(), assp)));
|
||
}
|
||
//lifeDump();
|
||
}
|
||
void complexAssign(AstVarScope* nodep) {
|
||
UINFO(4," clearof: "<<nodep<<endl);
|
||
LifeMap::iterator it = m_map.find(nodep);
|
||
if (it != m_map.end()) {
|
||
it->second.complexAssign();
|
||
} else {
|
||
m_map.insert(make_pair(nodep,LifeVarEntry(LifeVarEntry::COMPLEXASSIGN())));
|
||
}
|
||
}
|
||
void varUsageReplace (AstVarScope* nodep, AstVarRef* varrefp) {
|
||
// Variable rvalue. If it references a constant, we can simply replace it
|
||
LifeMap::iterator it = m_map.find(nodep);
|
||
if (it != m_map.end()) {
|
||
if (AstConst* constp = it->second.constNodep()) {
|
||
if (!varrefp->varp()->isSigPublic()) {
|
||
// Aha, variable is constant; substitute in.
|
||
// We'll later constant propagate
|
||
UINFO(4," replaceconst: "<<varrefp<<endl);
|
||
varrefp->replaceWith(constp->cloneTree(false));
|
||
varrefp->deleteTree(); varrefp=NULL;
|
||
m_statep->m_statAssnCon++;
|
||
return; // **DONE, no longer a var reference**
|
||
}
|
||
}
|
||
UINFO(4," usage: "<<nodep<<endl);
|
||
it->second.consumed();
|
||
} else {
|
||
m_map.insert(make_pair(nodep,LifeVarEntry(LifeVarEntry::CONSUMED())));
|
||
}
|
||
}
|
||
void complexAssignFind(AstVarScope* nodep) {
|
||
LifeMap::iterator it = m_map.find(nodep);
|
||
if (it != m_map.end()) {
|
||
UINFO(4," casfind: "<<it->first<<endl);
|
||
it->second.complexAssign();
|
||
} else {
|
||
m_map.insert(make_pair(nodep,LifeVarEntry(LifeVarEntry::COMPLEXASSIGN())));
|
||
}
|
||
}
|
||
void consumedFind(AstVarScope* nodep) {
|
||
LifeMap::iterator it = m_map.find(nodep);
|
||
if (it != m_map.end()) {
|
||
it->second.consumed();
|
||
} else {
|
||
m_map.insert(make_pair(nodep,LifeVarEntry(LifeVarEntry::CONSUMED())));
|
||
}
|
||
}
|
||
void lifeToAbove() {
|
||
// Any varrefs under a if/else branch affect statements outside and after the if/else
|
||
if (!m_aboveLifep) v3fatalSrc("Pushing life when already at the top level");
|
||
for (LifeMap::iterator it = m_map.begin(); it!=m_map.end(); ++it) {
|
||
AstVarScope* nodep = it->first;
|
||
m_aboveLifep->complexAssignFind(nodep);
|
||
if (it->second.everSet()) {
|
||
// Record there may be an assignment, so we don't constant propagate across the if.
|
||
complexAssignFind(nodep);
|
||
} else {
|
||
// Record consumption, so we don't eliminate earlier assignments
|
||
consumedFind(nodep);
|
||
}
|
||
}
|
||
}
|
||
void dualBranch (LifeBlock* life1p, LifeBlock* life2p) {
|
||
// Find any common sets on both branches of IF and propagate upwards
|
||
//life1p->lifeDump();
|
||
//life2p->lifeDump();
|
||
AstNode::userClearTree(); // userp() used on entire tree
|
||
for (LifeMap::iterator it = life1p->m_map.begin(); it!=life1p->m_map.end(); ++it) {
|
||
// When the if branch sets a var before it's used, mark that variable
|
||
if (it->second.setBeforeUse()) it->first->user(1);
|
||
}
|
||
for (LifeMap::iterator it = life2p->m_map.begin(); it!=life2p->m_map.end(); ++it) {
|
||
// When the else branch sets a var before it's used
|
||
AstVarScope* nodep = it->first;
|
||
if (it->second.setBeforeUse() && nodep->user()) {
|
||
// Both branches set the var, we can remove the assignment before the IF.
|
||
UINFO(4,"DUALBRANCH "<<nodep<<endl);
|
||
LifeMap::iterator itab = m_map.find(nodep);
|
||
if (itab != m_map.end()) {
|
||
checkRemoveAssign(itab);
|
||
}
|
||
}
|
||
}
|
||
//this->lifeDump();
|
||
}
|
||
// DEBUG
|
||
void lifeDump() {
|
||
UINFO(5, " LifeMap:"<<endl);
|
||
for (LifeMap::iterator it = m_map.begin(); it!=m_map.end(); ++it) {
|
||
UINFO(5, " Ent: "
|
||
<<(it->second.setBeforeUse()?"[F] ":" ")
|
||
<<it->first<<endl);
|
||
if (it->second.assignp()) {
|
||
UINFO(5, " Ass: "<<it->second.assignp()<<endl);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
//######################################################################
|
||
// Life state, as a visitor of each AstNode
|
||
|
||
class LifeVisitor : public AstNVisitor {
|
||
private:
|
||
// STATE
|
||
LifeState* m_statep; // Current state
|
||
bool m_sideEffect; // Side effects discovered in assign RHS
|
||
//static int debug() { return 9; }
|
||
|
||
// LIFE MAP
|
||
// For each basic block, we'll make a new map of what variables that if/else is changing
|
||
typedef std::map<AstVarScope*, LifeVarEntry> LifeMap;
|
||
LifeBlock* m_lifep; // Current active lifetime map for current scope
|
||
|
||
// METHODS
|
||
// VISITORS
|
||
virtual void visit(AstVarRef* nodep, AstNUser*) {
|
||
// Consumption/generation of a variable,
|
||
// it's used so can't elim assignment before this use.
|
||
if (!nodep->varScopep()) nodep->v3fatalSrc("NULL");
|
||
//
|
||
AstVarScope* vscp = nodep->varScopep();
|
||
if (!vscp) nodep->v3fatalSrc("Scope not assigned");
|
||
if (nodep->lvalue()) {
|
||
m_lifep->complexAssign(vscp);
|
||
} else {
|
||
m_lifep->varUsageReplace(vscp, nodep); nodep=NULL;
|
||
}
|
||
}
|
||
virtual void visit(AstNodeAssign* nodep, AstNUser*) {
|
||
// Collect any used variables first, as lhs may also be on rhs
|
||
// Similar code in V3Dead
|
||
vluint64_t lastEdit = AstNode::editCountGbl(); // When it was last edited
|
||
m_sideEffect = false;
|
||
nodep->rhsp()->iterateAndNext(*this);
|
||
if (lastEdit != AstNode::editCountGbl()) {
|
||
// We changed something, try to constant propagate, but don't delete the
|
||
// assignment as we still need nodep to remain.
|
||
V3Const::constifyTree(nodep->rhsp());
|
||
}
|
||
// Has to be direct assignment without any EXTRACTing.
|
||
if (nodep->lhsp()->castVarRef() && !m_sideEffect) {
|
||
AstVarScope* vscp = nodep->lhsp()->castVarRef()->varScopep();
|
||
if (!vscp) vscp->v3fatalSrc("Scope lost on variable");
|
||
m_lifep->simpleAssign(vscp, nodep);
|
||
} else {
|
||
nodep->lhsp()->iterateAndNext(*this);
|
||
}
|
||
}
|
||
virtual void visit(AstAssignDly* nodep, AstNUser*) {
|
||
// Don't treat as normal assign; V3Life doesn't understand time sense
|
||
nodep->iterateChildren(*this);
|
||
}
|
||
|
||
//---- Track control flow changes
|
||
virtual void visit(AstNodeIf* nodep, AstNUser*) {
|
||
UINFO(4," IF "<<nodep<<endl);
|
||
// Condition is part of PREVIOUS block
|
||
nodep->condp()->iterateAndNext(*this);
|
||
LifeBlock* prevLifep = m_lifep;
|
||
LifeBlock* ifLifep = new LifeBlock (prevLifep, m_statep);
|
||
LifeBlock* elseLifep = new LifeBlock (prevLifep, m_statep);
|
||
{
|
||
m_lifep = ifLifep;
|
||
nodep->ifsp()->iterateAndNext(*this);
|
||
m_lifep = prevLifep;
|
||
}
|
||
{
|
||
m_lifep = elseLifep;
|
||
nodep->elsesp()->iterateAndNext(*this);
|
||
m_lifep = prevLifep;
|
||
}
|
||
UINFO(4," join "<<endl);
|
||
// Find sets on both flows
|
||
m_lifep->dualBranch (ifLifep, elseLifep);
|
||
// For the next assignments, clear any variables that were read or written in the block
|
||
ifLifep->lifeToAbove();
|
||
elseLifep->lifeToAbove();
|
||
delete ifLifep;
|
||
delete elseLifep;
|
||
}
|
||
|
||
virtual void visit(AstWhile* nodep, AstNUser*) {
|
||
// While's are a problem, as we don't allow loops in the graph. We
|
||
// may go around the cond/body multiple times. Thus a
|
||
// lifelication just in the body is ok, but we can't delete an
|
||
// assignment in the body that's used in the cond. (And otherwise
|
||
// would because it only appears used after-the-fact. So, we model
|
||
// it as a IF statement, and just don't allow elimination of
|
||
// variables across the body.
|
||
LifeBlock* prevLifep = m_lifep;
|
||
LifeBlock* condLifep = new LifeBlock (prevLifep, m_statep);
|
||
LifeBlock* bodyLifep = new LifeBlock (prevLifep, m_statep);
|
||
{
|
||
m_lifep = condLifep;
|
||
nodep->precondsp()->iterateAndNext(*this);
|
||
nodep->condp()->iterateAndNext(*this);
|
||
m_lifep = prevLifep;
|
||
}
|
||
{
|
||
m_lifep = bodyLifep;
|
||
nodep->bodysp()->iterateAndNext(*this);
|
||
m_lifep = prevLifep;
|
||
}
|
||
UINFO(4," joinfor"<<endl);
|
||
// For the next assignments, clear any variables that were read or written in the block
|
||
condLifep->lifeToAbove();
|
||
bodyLifep->lifeToAbove();
|
||
delete condLifep;
|
||
delete bodyLifep;
|
||
}
|
||
virtual void visit(AstCCall* nodep, AstNUser*) {
|
||
//UINFO(4," CCALL "<<nodep<<endl);
|
||
nodep->iterateChildren(*this);
|
||
// Enter the function and trace it
|
||
nodep->funcp()->accept(*this);
|
||
}
|
||
virtual void visit(AstUCFunc* nodep, AstNUser*) {
|
||
m_sideEffect = true; // If appears on assign RHS, don't ever delete the assignment
|
||
nodep->iterateChildren(*this);
|
||
}
|
||
|
||
virtual void visit(AstVar*, AstNUser*) {} // Don't want varrefs under it
|
||
virtual void visit(AstNode* nodep, AstNUser*) {
|
||
nodep->iterateChildren(*this);
|
||
}
|
||
|
||
public:
|
||
// CONSTRUCTORS
|
||
LifeVisitor(AstNode* nodep, LifeState* statep) {
|
||
UINFO(4," LifeVisitor on "<<nodep<<endl);
|
||
m_statep = statep;
|
||
m_sideEffect = false;
|
||
{
|
||
m_lifep = new LifeBlock (NULL, m_statep);
|
||
nodep->accept(*this);
|
||
delete m_lifep; m_lifep=NULL;
|
||
}
|
||
}
|
||
virtual ~LifeVisitor() {}
|
||
};
|
||
|
||
//######################################################################
|
||
|
||
class LifeTopVisitor : public AstNVisitor {
|
||
// Visit all top nodes searching for functions that are entry points we want to start
|
||
// finding code within.
|
||
private:
|
||
// STATE
|
||
LifeState* m_statep; // Current state
|
||
|
||
// VISITORS
|
||
virtual void visit(AstCFunc* nodep, AstNUser*) {
|
||
if (nodep->entryPoint()) {
|
||
// Usage model 1: Simulate all C code, doing lifetime analysis
|
||
LifeVisitor visitor (nodep, m_statep);
|
||
}
|
||
}
|
||
virtual void visit(AstAlways* nodep, AstNUser*) {
|
||
// Usage model 2: Cleanup basic blocks
|
||
LifeVisitor visitor (nodep, m_statep);
|
||
}
|
||
virtual void visit(AstInitial* nodep, AstNUser*) {
|
||
// Usage model 2: Cleanup basic blocks
|
||
LifeVisitor visitor (nodep, m_statep);
|
||
}
|
||
virtual void visit(AstFinal* nodep, AstNUser*) {
|
||
// Usage model 2: Cleanup basic blocks
|
||
LifeVisitor visitor (nodep, m_statep);
|
||
}
|
||
virtual void visit(AstVar*, AstNUser*) {} // Accelerate
|
||
virtual void visit(AstNodeStmt*, AstNUser*) {} // Accelerate
|
||
virtual void visit(AstNodeMath*, AstNUser*) {} // Accelerate
|
||
virtual void visit(AstNode* nodep, AstNUser*) {
|
||
nodep->iterateChildren(*this);
|
||
}
|
||
public:
|
||
// CONSTRUCTORS
|
||
LifeTopVisitor(AstNetlist* nodep, LifeState* statep) {
|
||
m_statep = statep;
|
||
nodep->accept(*this);
|
||
}
|
||
virtual ~LifeTopVisitor() {}
|
||
};
|
||
|
||
//######################################################################
|
||
// Life class functions
|
||
|
||
void V3Life::lifeAll(AstNetlist* nodep) {
|
||
UINFO(2,__FUNCTION__<<": "<<endl);
|
||
LifeState state;
|
||
LifeTopVisitor visitor (nodep, &state);
|
||
}
|