def searchConstantDefinition(self, key, name):
foundkey, founddef = self.frames.searchConstantDefinition(key, name)
if foundkey is not None:
return foundkey + ScopeLabel(name, 'signal'), founddef
foundkey, founddef = self.frames.searchSignalDefinition(key, name)
if foundkey is not None:
return foundkey + ScopeLabel(name, 'signal'), founddef
if foundkey is None:
raise verror.DefinitionError('constant value not found: %s' % name)
def toScopeChain(self, blocklabel):
scopelist = []
for b in blocklabel.labellist:
if b.loop is not None:
loop = self.optimize(b.loop)
if not isinstance(loop, DFEvalValue):
raise verror.FormatError('Loop iterator should be constant')
scopelist.append(ScopeLabel(b.name, 'for', loop))
scopelist.append(ScopeLabel(b.name, 'any'))
return ScopeChain(scopelist)
def stackInstanceFrame(self, instname, modulename):
current = self.frames.addFrame(ScopeLabel(instname, 'module'),
module=True,
modulename=modulename)
self.frames.updateSignal(self.moduleinfotable.getSignals(modulename))
self.frames.updateConst(self.moduleinfotable.getConsts(modulename))
return current
def visit_Always(self, node):
label = self.labels.get(self.frames.getLabelKey('always'))
current = self.frames.addFrame(ScopeLabel(label, 'always'),
generate=self.frames.isGenerate(),
always=True)
self.generic_visit(node)
self.frames.setCurrent(current)
def getAllFunctions(self):
ret = collections.OrderedDict()
for dk, dv in self.dict.items():
ret.update(
map_key((lambda x: dk + ScopeLabel(x, 'function')),
dv.getFunctions()))
return ret
def searchScopeConstantValue(self, blocklabel, name):
currentmodule = self.frames.getCurrentModuleScopeChain()
localchain = currentmodule[-1:] + self.toScopeChain(blocklabel)
matchedchain = self.frames.searchMatchedScopeChain(currentmodule, localchain)
varname = currentmodule[:-1] + matchedchain + ScopeLabel(name, 'signal')
const = self.getConstant(varname)
return const
def visit_Localparam(self, node):
self.frames.addConst(node)
name = self.frames.getCurrent() + ScopeLabel(node.name, 'signal')
if not self.hasConstant(name):
value = self.optimize(
self.getTree(node.value, self.frames.getCurrent()))
self.setConstant(name, value)
def toTermname_list(name):
scopechain_list = []
for n in name:
if not isinstance(n, str):
raise TypeError()
scopechain_list.append(ScopeLabel(n, 'any'))
return ScopeChain(scopechain_list)
def _if_false(self, node, label):
if node.false_statement is None: return
label = self._toELSE(label)
current = self.frames.addFrame(ScopeLabel(label, 'if'),
frametype='ifelse',
condition=node.cond,
functioncall=self.frames.isFunctioncall(),
taskcall=self.frames.isTaskcall(),
generate=self.frames.isGenerate(),
always=self.frames.isAlways(),
initial=self.frames.isInitial())
self.visit(node.false_statement)
self.frames.setCurrent(current)
return label
def _if_true(self, node):
if node.true_statement is None: return None
label = self.labels.get( self.frames.getLabelKey('if') )
current = self.frames.addFrame(ScopeLabel(label, 'if'),
frametype='ifthen',
condition=node.cond,
functioncall=self.frames.isFunctioncall(),
taskcall=self.frames.isTaskcall(),
generate=self.frames.isGenerate(),
always=self.frames.isAlways(),
initial=self.frames.isInitial())
self.visit(node.true_statement)
self.frames.setCurrent(current)
return label
def visit_Block(self, node):
label = None
if node.scope is not None:
label = node.scope
else:
label = self.labels.get(self.frames.getLabelKey('block'))
current = self.frames.addFrame(ScopeLabel(label, 'block'),
frametype='block',
functioncall=self.frames.isFunctioncall(),
taskcall=self.frames.isTaskcall(),
generate=self.frames.isGenerate(),
always=self.frames.isAlways(),
initial=self.frames.isInitial())
self.generic_visit(node)
self.frames.setCurrent(current)
def visit_ForStatement(self, node):
## pre-statement
current = self.frames.getCurrent()
pre_right = self.getTree(node.pre.right, current)
pre_right_value = self.optimize(pre_right)
loop = pre_right_value.value
self.frames.setForPre()
self.visit(node.pre)
self.frames.unsetForPre()
label = self.labels.get(self.frames.getLabelKey('for'))
#loop = 0
while True:
## cond-statement
current = self.frames.getCurrent()
tree = self.getTree(node.cond, current)
rslt = self.optimize(tree)
if not isinstance(rslt, DFEvalValue):
raise verror.FormatError(
("Can not process the for-statement. "
"for-condition should be evaluated statically."))
# loop termination
if rslt.value <= 0: break
## main-statement
current = self.frames.addFrame(
ScopeLabel(label, 'for', loop),
frametype='for',
functioncall=self.frames.isFunctioncall(),
taskcall=self.frames.isTaskcall(),
generate=self.frames.isGenerate(),
always=self.frames.isAlways(),
initial=self.frames.isInitial(),
loop=loop,
loop_iter=self.frames.getForIter())
self.visit(node.statement)
self.frames.setCurrent(current)
## post-statement
current = self.frames.getCurrent()
post_right = self.getTree(node.post.right, current)
post_right_value = self.optimize(post_right)
loop = post_right_value.value
self.frames.setForPost()
self.visit(node.post)
self.frames.unsetForPost()
def getFunctions(self, scope):
return map_key(
(lambda x: scope + ScopeLabel(x, 'function')), self.dict[scope].getFunctions())
def toTermname_str(name):
scopechain_list = []
for n in name.split('.'):
# fix me: to support "module.scope.signal[ptr]", lexical analyzer is required.
scopechain_list.append(ScopeLabel(n, 'any'))
return ScopeChain(scopechain_list)
def getConsts(self, scope):
return map_key(
(lambda x: scope + ScopeLabel(x, 'signal')), self.dict[scope].getConsts())
def generate(self):
code_parser = VerilogCodeParser(self.filelist,
preprocess_include=self.include,
preprocess_define=self.define)
ast = code_parser.parse()
module_visitor = ModuleVisitor()
module_visitor.visit(ast)
modulenames = module_visitor.get_modulenames()
moduleinfotable = module_visitor.get_moduleinfotable()
template_parser = VerilogCodeParser((self.template_file, ))
template_ast = template_parser.parse()
template_visitor = ModuleVisitor()
template_visitor.visit(template_ast)
templateinfotable = template_visitor.get_moduleinfotable()
instanceconvert_visitor = InstanceConvertVisitor(
moduleinfotable, self.topmodule, templateinfotable)
instanceconvert_visitor.start_visit()
replaced_instance = instanceconvert_visitor.getMergedReplacedInstance()
replaced_instports = instanceconvert_visitor.getReplacedInstPorts()
replaced_items = instanceconvert_visitor.getReplacedItems()
new_moduleinfotable = instanceconvert_visitor.get_new_moduleinfotable()
instancereplace_visitor = InstanceReplaceVisitor(
replaced_instance, replaced_instports, replaced_items,
new_moduleinfotable)
ret = instancereplace_visitor.getAST()
# gather user-defined io-ports on top-module and parameters to connect external
frametable = instanceconvert_visitor.getFrameTable()
top_ioports = []
for i in moduleinfotable.getIOPorts(self.topmodule):
if signaltype.isClock(i) or signaltype.isReset(i): continue
top_ioports.append(i)
top_sigs = frametable.getSignals(
ScopeChain([ScopeLabel(self.topmodule, 'module')]))
top_params = frametable.getConsts(
ScopeChain([ScopeLabel(self.topmodule, 'module')]))
for sk, sv in top_sigs.items():
if len(sk) > 2: continue
signame = sk[1].scopename
for svv in sv:
if (signame in top_ioports
and not (signaltype.isClock(signame)
or signaltype.isReset(signame))
and isinstance(svv, vast.Input)
or isinstance(svv, vast.Output)
or isinstance(svv, vast.Inout)):
port = svv
self.top_ioports[signame] = port
break
for ck, cv in top_params.items():
if len(ck) > 2: continue
signame = ck[1].scopename
param = cv[0]
if isinstance(param, vast.Genvar): continue
self.top_parameters[signame] = param
self.target_object = instanceconvert_visitor.getTargetObject()
return ret
def visit_Genvar(self, node):
self.frames.addConst(node)
name = self.frames.getCurrent() + ScopeLabel(node.name, 'signal')
if not self.hasConstant(name):
value = DFEvalValue(0)
self.setConstant(name, value)
return self.visit_CaseStatement(node)
def _case(self, comp, caselist):
if len(caselist) == 0:
return
case = caselist[0]
cond = IntConst('1')
if case.cond is not None:
if len(case.cond) > 1:
cond = Eq(comp, case.cond[0])
for c in case.cond[1:]:
cond = Lor(cond, Eq(comp, c))
else:
cond = Eq(comp, case.cond[0])
label = self.labels.get(self.frames.getLabelKey('if'))
current = self.frames.addFrame(ScopeLabel(label, 'if'),
frametype='ifthen',
condition=cond,
functioncall=self.frames.isFunctioncall(),
taskcall=self.frames.isTaskcall(),
generate=self.frames.isGenerate(),
always=self.frames.isAlways(),
initial=self.frames.isInitial())
if case.statement is not None:
self.visit(case.statement)
self.frames.setCurrent(current)
if len(caselist) == 1:
return
label = self._toELSE(label)
current = self.frames.addFrame(ScopeLabel(label, 'if'),
frametype='ifelse',
return self.visit_CaseStatement(node)
def _case(self, comp, caselist):
if len(caselist) == 0: return
case = caselist[0]
cond = IntConst('1')
if case.cond is not None:
if len(case.cond) > 1:
cond = Eq(comp, case.cond[0])
for c in case.cond[1:]:
cond = Lor(cond, Eq(comp, c))
else:
cond = Eq(comp, case.cond[0])
label = self.labels.get(self.frames.getLabelKey('if'))
current = self.frames.addFrame(
ScopeLabel(label, 'if'),
frametype='ifthen',
condition=cond,
functioncall=self.frames.isFunctioncall(),
taskcall=self.frames.isTaskcall(),
generate=self.frames.isGenerate(),
always=self.frames.isAlways(),
initial=self.frames.isInitial())
if case.statement is not None: self.visit(case.statement)
self.frames.setCurrent(current)
if len(caselist) == 1: return
label = self._toELSE(label)
current = self.frames.addFrame(
ScopeLabel(label, 'if'),
frametype='ifelse',
condition=cond,
def getTasks(self, scope):
return map_key(
(lambda x: scope + ScopeLabel(x, 'task')), self.dict[scope].getTasks())
def generate(self):
preprocess_define = []
if self.single_clock:
preprocess_define.append('CORAM_SINGLE_CLOCK')
if self.define:
preprocess_define.extend(self.define)
code_parser = VerilogCodeParser(self.filelist,
preprocess_include=self.include,
preprocess_define=preprocess_define)
ast = code_parser.parse()
module_visitor = ModuleVisitor()
module_visitor.visit(ast)
modulenames = module_visitor.get_modulenames()
moduleinfotable = module_visitor.get_moduleinfotable()
instanceconvert_visitor = InstanceConvertVisitor(
moduleinfotable, self.topmodule)
instanceconvert_visitor.start_visit()
replaced_instance = instanceconvert_visitor.getMergedReplacedInstance()
replaced_instports = instanceconvert_visitor.getReplacedInstPorts()
replaced_items = instanceconvert_visitor.getReplacedItems()
new_moduleinfotable = instanceconvert_visitor.get_new_moduleinfotable()
instancereplace_visitor = InstanceReplaceVisitor(
replaced_instance, replaced_instports, replaced_items,
new_moduleinfotable)
ret = instancereplace_visitor.getAST()
# gather user-defined io-ports on top-module and parameters to connect external
frametable = instanceconvert_visitor.getFrameTable()
top_ioports = []
for i in moduleinfotable.getIOPorts(self.topmodule):
if signaltype.isClock(i) or signaltype.isReset(i): continue
top_ioports.append(i)
top_scope = ScopeChain([ScopeLabel(self.topmodule, 'module')])
top_sigs = frametable.getSignals(top_scope)
top_params = frametable.getConsts(top_scope)
for sk, sv in top_sigs.items():
if len(sk) > 2: continue
signame = sk[1].scopename
for svv in sv:
if (signame in top_ioports
and not (signaltype.isClock(signame)
or signaltype.isReset(signame))
and isinstance(svv, vast.Input)
or isinstance(svv, vast.Output)
or isinstance(svv, vast.Inout)):
port = svv
msb_val = instanceconvert_visitor.optimize(
instanceconvert_visitor.getTree(
port.width.msb, top_scope))
lsb_val = instanceconvert_visitor.optimize(
instanceconvert_visitor.getTree(
port.width.lsb, top_scope))
width = int(msb_val.value) - int(lsb_val.value) + 1
self.top_ioports[signame] = (port, width)
break
for ck, cv in top_params.items():
if len(ck) > 2: continue
signame = ck[1].scopename
param = cv[0]
if isinstance(param, vast.Genvar): continue
self.top_parameters[signame] = param
self.coram_object = instanceconvert_visitor.getCoramObject()
return ret
def visit_GenerateStatement(self, node):
label = self.labels.get(self.frames.getLabelKey('generate'))
current = self.frames.addFrame(ScopeLabel(label, 'generate'),
generate=True)
self.generic_visit(node)
self.frames.setCurrent(current)
