mirror of
https://github.com/verilator/verilator.git
synced 2025-02-01 11:14:03 +00:00
b5b1d94d4a
git-svn-id: file://localhost/svn/verilator/trunk/verilator@864 77ca24e4-aefa-0310-84f0-b9a241c72d87
354 lines
12 KiB
C++
354 lines
12 KiB
C++
// $Id$
|
||
//*************************************************************************
|
||
// DESCRIPTION: Verilator: Replicate modules for parameterization
|
||
//
|
||
// Code available from: http://www.veripool.com/verilator
|
||
//
|
||
// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
|
||
//
|
||
//*************************************************************************
|
||
//
|
||
// Copyright 2003-2007 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.
|
||
//
|
||
//*************************************************************************
|
||
// PARAM TRANSFORMATIONS:
|
||
// Top down traversal:
|
||
// For each cell:
|
||
// If parameterized,
|
||
// Determine all parameter widths, constant values
|
||
// Clone module cell calls, renaming with __{par1}_{par2}_...
|
||
// Substitute constants for cell's module's parameters
|
||
// Relink pins and cell to point to new module
|
||
//
|
||
//*************************************************************************
|
||
|
||
#include "config_build.h"
|
||
#include "verilatedos.h"
|
||
#include <stdio.h>
|
||
#include <stdarg.h>
|
||
#include <unistd.h>
|
||
#include <map>
|
||
#include <vector>
|
||
|
||
#include "V3Global.h"
|
||
#include "V3Param.h"
|
||
#include "V3Read.h"
|
||
#include "V3Ast.h"
|
||
#include "V3Case.h"
|
||
#include "V3Const.h"
|
||
#include "V3Width.h"
|
||
#include "V3Signed.h"
|
||
#include "V3Unroll.h"
|
||
|
||
//######################################################################
|
||
// Param state, as a visitor of each AstNode
|
||
|
||
class ParamVisitor : public AstNVisitor {
|
||
private:
|
||
// NODE STATE
|
||
// AstModule::user4() // bool True if parameters numbered
|
||
// AstVar::user4() // int Global parameter number (for naming new module)
|
||
// STATE
|
||
typedef std::map<AstVar*,AstVar*> VarCloneMap;
|
||
struct ModInfo {
|
||
AstModule* m_modp; // Module with specified name
|
||
VarCloneMap m_cloneMap; // Map of old-varp -> new cloned varp
|
||
ModInfo(AstModule* modp) { m_modp=modp; }
|
||
};
|
||
typedef std::map<string,ModInfo> ModNameMap;
|
||
ModNameMap m_modNameMap; // Hash of created module flavors by name
|
||
|
||
typedef std::map<string,string> LongMap;
|
||
LongMap m_longMap; // Hash of very long names to unique identity number
|
||
int m_longId;
|
||
|
||
//int debug() { return 9; }
|
||
|
||
// METHODS
|
||
void makeSmallNames(AstModule* modp) {
|
||
vector<int> usedLetter; usedLetter.resize(256);
|
||
// Pass 1, assign first letter to each gparam's name
|
||
for (AstNode* stmtp = modp->stmtsp(); stmtp; stmtp=stmtp->nextp()) {
|
||
if (AstVar* varp = stmtp->castVar()) {
|
||
if (varp->isGParam()) {
|
||
char ch = varp->name()[0];
|
||
ch = toupper(ch); if (ch<'A' || ch>'Z') ch='Z';
|
||
varp->user4(usedLetter[ch]*256 + ch);
|
||
usedLetter[ch]++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
string paramSmallName(AstModule* modp, AstVar* varp) {
|
||
if (!varp->user4()) {
|
||
makeSmallNames(modp);
|
||
}
|
||
int index = varp->user4()/256;
|
||
char ch = varp->user4()&255;
|
||
string st = cvtToStr(ch);
|
||
while (index) {
|
||
st += cvtToStr(char((index%26)+'A'));
|
||
index /= 26;
|
||
}
|
||
return st;
|
||
}
|
||
void relinkPins(VarCloneMap* clonemapp, AstPin* startpinp) {
|
||
for (AstPin* pinp = startpinp; pinp; pinp=pinp->nextp()->castPin()) {
|
||
if (!pinp->modVarp()) pinp->v3fatalSrc("Not linked?\n");
|
||
// Find it in the clone structure
|
||
//UINFO(8,"Clone find 0x"<<hex<<(uint32_t)pinp->modVarp()<<endl);
|
||
VarCloneMap::iterator cloneiter = clonemapp->find(pinp->modVarp());
|
||
UASSERT(cloneiter != clonemapp->end(), "Couldn't find pin in clone list");
|
||
pinp->modVarp(cloneiter->second);
|
||
}
|
||
}
|
||
|
||
// VISITORS
|
||
virtual void visit(AstNetlist* nodep, AstNUser*) {
|
||
AstNode::user4ClearTree();
|
||
// Modules must be done in top-down-order
|
||
nodep->iterateChildren(*this);
|
||
}
|
||
virtual void visit(AstModule* nodep, AstNUser*) {
|
||
UINFO(4," MOD "<<nodep<<endl);
|
||
nodep->iterateChildren(*this);
|
||
}
|
||
virtual void visit(AstCell* nodep, AstNUser*);
|
||
|
||
// Generate Statements
|
||
virtual void visit(AstGenerate* nodep, AstNUser*) {
|
||
if (debug()>=9) nodep->dumpTree(cout,"-genin: ");
|
||
nodep->iterateChildren(*this);
|
||
// After expanding the generate, all statements under it can be moved
|
||
// up, and the generate block deleted as it's not relevant
|
||
if (AstNode* stmtsp = nodep->stmtsp()) {
|
||
stmtsp->unlinkFrBackWithNext();
|
||
nodep->replaceWith(stmtsp);
|
||
if (debug()>=9) stmtsp->dumpTree(cout,"-genout: ");
|
||
} else {
|
||
nodep->unlinkFrBack();
|
||
}
|
||
nodep->deleteTree(); nodep=NULL;
|
||
}
|
||
virtual void visit(AstGenIf* nodep, AstNUser*) {
|
||
V3Width::widthParams(nodep); // Param typed widthing will NOT recurse the body
|
||
V3Signed::signedParams(nodep);
|
||
V3Const::constifyParam(nodep->condp());
|
||
if (AstConst* constp = nodep->condp()->castConst()) {
|
||
AstNode* keepp = (constp->isZero()
|
||
? nodep->elsesp()
|
||
: nodep->ifsp());
|
||
if (keepp) {
|
||
keepp->unlinkFrBackWithNext();
|
||
nodep->replaceWith(keepp);
|
||
} else {
|
||
nodep->unlinkFrBack();
|
||
}
|
||
nodep->deleteTree(); nodep=NULL;
|
||
} else {
|
||
nodep->condp()->v3error("Generate If condition must evaluate to constant");
|
||
}
|
||
}
|
||
virtual void visit(AstGenFor* nodep, AstNUser*) {
|
||
// We parse a very limited form of FOR, so we don't need to do a full
|
||
// simulation to unroll the loop
|
||
V3Width::widthParams(nodep); // Param typed widthing will NOT recurse the body
|
||
V3Signed::signedParams(nodep);
|
||
V3Unroll::unrollGen(nodep); nodep=NULL;
|
||
}
|
||
virtual void visit(AstGenCase* nodep, AstNUser*) {
|
||
AstNode* keepp = NULL;
|
||
V3Case::caseLint(nodep);
|
||
V3Width::widthParams(nodep); // Param typed widthing will NOT recurse the body
|
||
V3Signed::signedParams(nodep);
|
||
V3Const::constifyParam(nodep->exprp());
|
||
AstConst* exprp = nodep->exprp()->castConst();
|
||
// Constify
|
||
for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
|
||
for (AstNode* ep = itemp->condsp(); ep; ) {
|
||
AstNode* nextp = ep->nextp(); //May edit list
|
||
V3Const::constifyParam(ep);
|
||
ep = nextp;
|
||
}
|
||
}
|
||
// Item match
|
||
for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
|
||
if (!itemp->isDefault()) {
|
||
for (AstNode* ep = itemp->condsp(); ep; ep=ep->nextp()) {
|
||
if (AstConst* ccondp = ep->castConst()) {
|
||
V3Number match (nodep->fileline(), 1);
|
||
match.opEq(ccondp->num(), exprp->num());
|
||
if (!keepp && match.isNeqZero()) {
|
||
keepp = itemp->bodysp();
|
||
}
|
||
} else {
|
||
itemp->v3error("Generate Case item does not evaluate to constant");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Else default match
|
||
for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
|
||
if (itemp->isDefault()) {
|
||
if (!keepp) keepp=itemp->bodysp();
|
||
}
|
||
}
|
||
// Replace
|
||
if (keepp) {
|
||
keepp->unlinkFrBackWithNext();
|
||
nodep->replaceWith(keepp);
|
||
}
|
||
else nodep->unlinkFrBack();
|
||
nodep->deleteTree(); nodep=NULL;
|
||
}
|
||
|
||
// Default: Just iterate
|
||
virtual void visit(AstNode* nodep, AstNUser*) {
|
||
nodep->iterateChildren(*this);
|
||
}
|
||
|
||
public:
|
||
// CONSTUCTORS
|
||
ParamVisitor(AstNetlist* nodep) {
|
||
m_longId = 0;
|
||
//
|
||
nodep->accept(*this);
|
||
}
|
||
virtual ~ParamVisitor() {}
|
||
};
|
||
|
||
//----------------------------------------------------------------------
|
||
// VISITs
|
||
|
||
void ParamVisitor::visit(AstCell* nodep, AstNUser*) {
|
||
// Cell: Check for parameters in the instantiation.
|
||
if (!nodep->modp()) { nodep->dumpTree(cout,"error:"); nodep->v3fatalSrc("Not linked?"); }
|
||
if (nodep->paramsp()) {
|
||
UINFO(4,"De-parameterize: "<<nodep<<endl);
|
||
// Create new module name with _'s between the constants
|
||
if (debug()>9) nodep->dumpTree(cout,"cell:\t");
|
||
// Evaluate all module constants
|
||
V3Const::constifyParam(nodep);
|
||
// Make sure constification worked
|
||
// Must be a separate loop, as constant conversion may have changed some pointers.
|
||
//if (debug()) nodep->dumpTree(cout,"cel2:\t");
|
||
string longname = nodep->modp()->name();
|
||
longname += "_";
|
||
if (debug()>8) nodep->paramsp()->dumpTreeAndNext(cout,"-cellparams:\t");
|
||
for (AstPin* pinp = nodep->paramsp(); pinp; pinp=pinp->nextp()->castPin()) {
|
||
if (!pinp) nodep->v3fatalSrc("Non pin under cell params\n");
|
||
AstVar* modvarp = pinp->modVarp();
|
||
if (!modvarp) {
|
||
pinp->v3error("Parameter not found in sub-module: Param "<<pinp->name()<<" of "<<nodep->prettyName());
|
||
} else if (!modvarp->isGParam()) {
|
||
pinp->v3error("Attempted parameter setting of non-parameter: Param "<<pinp->name()<<" of "<<nodep->prettyName());
|
||
} else {
|
||
AstConst* constp = pinp->exprp()->castConst();
|
||
if (!constp) {
|
||
//if (debug()) pinp->dumpTree(cout,"error:");
|
||
pinp->v3error("Can't convert defparam value to constant: Param "<<pinp->name()<<" of "<<nodep->prettyName());
|
||
} else {
|
||
longname += "_" + paramSmallName(nodep->modp(),pinp->modVarp())+constp->num().ascii(false);
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// If the name is very long, we don't want to overwhelm the filename limit
|
||
// We don't do this always, as it aids debugability to have intuitive naming.
|
||
string newname = longname;
|
||
if (longname.length()>30) {
|
||
LongMap::iterator iter = m_longMap.find(longname);
|
||
if (iter != m_longMap.end()) {
|
||
newname = iter->second;
|
||
} else {
|
||
newname = nodep->modp()->name();
|
||
newname += "__pi"+cvtToStr(++m_longId); // We use all upper case above, so lower here can't conflict
|
||
m_longMap.insert(make_pair(longname, newname));
|
||
}
|
||
}
|
||
UINFO(4,"Name: "<<nodep->modp()->name()<<"->"<<longname<<"->"<<newname<<endl);
|
||
|
||
//
|
||
// Already made this flavor?
|
||
AstModule* modp = NULL;
|
||
ModNameMap::iterator iter = m_modNameMap.find(newname);
|
||
if (iter != m_modNameMap.end()) modp = iter->second.m_modp;
|
||
if (!modp) {
|
||
// Deep clone of new module
|
||
// Note all module internal variables will be re-linked to the new modules by clone
|
||
// However links outside the module (like on the upper cells) will not.
|
||
modp = nodep->modp()->cloneTree(false)->castModule();
|
||
modp->name(newname);
|
||
nodep->modp()->addNextHere(modp); // Keep tree sorted by cell occurrences
|
||
|
||
m_modNameMap.insert(make_pair(modp->name(), ModInfo(modp)));
|
||
iter = m_modNameMap.find(newname);
|
||
VarCloneMap* clonemapp = &(iter->second.m_cloneMap);
|
||
UINFO(4," De-parameterize to new: "<<modp<<endl);
|
||
|
||
// Grab all I/O so we can remap our pins later
|
||
// Note we allow multiple users of a parameterized model, thus we need to stash this info.
|
||
for (AstNode* stmtp=modp->stmtsp(); stmtp; stmtp = stmtp->nextp()) {
|
||
if (AstVar* varp = stmtp->castVar()) {
|
||
if (varp->isIO() || varp->isGParam()) {
|
||
// Cloning saved a pointer to the new node for us, so just follow that link.
|
||
AstVar* oldvarp = varp->clonep()->castVar();
|
||
//UINFO(8,"Clone list 0x"<<hex<<(uint32_t)oldvarp<<" -> 0x"<<(uint32_t)varp<<endl);
|
||
clonemapp->insert(make_pair(oldvarp, varp));
|
||
}
|
||
}
|
||
}
|
||
|
||
// Relink parameter vars to the new module
|
||
relinkPins(clonemapp, nodep->paramsp());
|
||
|
||
// Assign parameters to the constants specified
|
||
for (AstPin* pinp = nodep->paramsp(); pinp; pinp=pinp->nextp()->castPin()) {
|
||
AstVar* modvarp = pinp->modVarp();
|
||
if (modvarp) {
|
||
AstConst* constp = pinp->exprp()->castConst();
|
||
// Remove any existing parameter
|
||
if (modvarp->initp()) modvarp->initp()->unlinkFrBack()->deleteTree();
|
||
// Set this parameter to value requested by cell
|
||
modvarp->initp(constp->cloneTree(false));
|
||
}
|
||
}
|
||
} else {
|
||
UINFO(4," De-parameterize to old: "<<modp<<endl);
|
||
}
|
||
|
||
// Have child use this module instead.
|
||
nodep->modp(modp);
|
||
nodep->modName(newname);
|
||
|
||
// Delete the parameters from the cell; they're not relevant any longer.
|
||
{
|
||
AstNRelinker delHandle;
|
||
nodep->paramsp()->unlinkFrBackWithNext(&delHandle);
|
||
delHandle.oldp()->deleteTree();
|
||
}
|
||
|
||
// We need to relink the pins to the new module
|
||
VarCloneMap* clonemapp = &(iter->second.m_cloneMap);
|
||
relinkPins(clonemapp, nodep->pinsp());
|
||
|
||
UINFO(8," Done with "<<modp<<endl);
|
||
}
|
||
}
|
||
|
||
//######################################################################
|
||
// Param class functions
|
||
|
||
void V3Param::param(AstNetlist* rootp) {
|
||
UINFO(2,__FUNCTION__<<": "<<endl);
|
||
ParamVisitor visitor (rootp);
|
||
}
|