def __call__(s, tr_top):
""" generate structural RTLIR for component `tr_top` """
s.tr_top = tr_top
if not hasattr(tr_top, "_rtlir_getter"):
tr_top._rtlir_getter = RTLIRGetter(cache=True)
try:
s._gen_metadata(tr_top)
except AssertionError as e:
msg = '' if not e.args is None else e.args[0]
raise RTLIRConversionError(tr_top, msg)
def __call__(s, tr_top):
""" generate structural RTLIR for component `tr_top` """
if not hasattr(tr_top, '_pass_structural_rtlir_gen'):
tr_top._pass_structural_rtlir_gen = PassMetadata()
s.tr_top = tr_top
try:
s.gen_rtlir_types(tr_top)
s.gen_constants(tr_top)
s.sort_connections(tr_top)
except AssertionError as e:
msg = '' if not e.args is None else e.args[0]
raise RTLIRConversionError(tr_top, msg)
def __call__(s, tr_top):
""" generate structural RTLIR for component `tr_top` """
c = s.__class__
s.tr_top = tr_top
if not tr_top.has_metadata(c.rtlir_getter):
tr_top.set_metadata(c.rtlir_getter, RTLIRGetter(cache=True))
try:
s._gen_metadata(tr_top)
except AssertionError as e:
msg = '' if not e.args is None else e.args[0]
raise RTLIRConversionError(tr_top, msg)
def gen_signal_expr(cur_component, signal):
"""Return an RTLIR signal expression for the given signal."""
try:
if isinstance(signal, dsl.Const):
c = signal._dsl.const
assert isinstance( c, ( int, Bits )) or is_bitstruct_inst( c ), \
f'{c} is not an integer/Bits/BitStruct const!'
return ConstInstance(signal, c)
assert isinstance(signal, dsl.Signal), f'{signal} is not supported!'
# Strip off all the tokens from the signal to the component
tmp = signal
stack = []
if tmp.is_sliced_signal():
stack.append((construct_slice, tmp._dsl.slice))
tmp = tmp.get_parent_object()
while tmp is not cur_component:
if tmp._dsl._my_indices:
for x in reversed(tmp._dsl._my_indices):
stack.append((construct_index, x))
stack.append((construct_attr, tmp._dsl._my_name))
tmp = tmp.get_parent_object()
cur_node = construct_base(tmp, tmp._dsl.my_name)
for f, token in reversed(stack):
cur_node = f(cur_node, token)
return cur_node
except AssertionError as e:
msg = '' if e.args[0] is None else e.args[0]
raise RTLIRConversionError(signal, msg)
def gen_signal_expr( cur_component, signal ):
"""Return an RTLIR signal expression for the given signal."""
def get_next_op( expr, cur_pos, my_name, full_name ):
"""Return the next signal operation in string `expr`.
Return value: ( op, *data )
op is one of [ 'Attr', 'Slice', 'Index', 'Base', 'Done' ].
*data is one to two variables that describes the next signal operation.
"""
if not expr[cur_pos:]: return ( 'Done', '' ), 0
pos = len( expr )
dot_pos = expr.find( '.', cur_pos+1 )
lb_pos = expr.find( '[', cur_pos+1 )
pos = dot_pos if dot_pos != -1 and dot_pos < pos else pos
pos = lb_pos if lb_pos != -1 and lb_pos < pos else pos
# Attribute operation
if expr[cur_pos] == '.': return ( 'Attr', expr[cur_pos+1:pos] ), pos
# Index or slice operation
elif expr[cur_pos] == '[':
rb_pos = expr.find( ']', cur_pos )
colon_pos = expr.find( ':', cur_pos )
assert rb_pos != -1 and pos == rb_pos+1, \
f"unrecognized expression {expr}"
if cur_pos < colon_pos < rb_pos:
start = int( expr[cur_pos+1:colon_pos] )
stop = int( expr[colon_pos+1:rb_pos] )
return ( 'Slice', start, stop ), pos
else:
return ( 'Index', int(expr[cur_pos+1:rb_pos]) ), pos
# The current component ( base of attribute )
else:
base_pos = expr.find( full_name )
assert base_pos >= 0, \
f"cannot find the base of attribute {full_name} in {expr}"
return ( 'Base', my_name ), base_pos + len( full_name )
def get_cls_inst( func_list, cur_node, ops ):
"""Return an IR instance of the given signal operation."""
classes = [ c for c in ( f( cur_node, *ops ) for f in func_list ) if c ]
assert len(classes) <= 1, f"internal error: not unique class {classes}!"
assert classes, f"internal error: no available expression nodes for {cur_node}!"
return classes[0]( cur_node, *ops )
try:
try:
expr = signal._dsl.full_name
base_comp = signal
except AttributeError:
# Special case for a ConstInstance because it has no name
assert hasattr( signal._dsl, 'const' ), f'{signal} is not supported!'
c = signal._dsl.const
assert isinstance( c, ( int, Bits )) or is_bitstruct_inst( c ), \
f'{signal._dsl.const} is not an integer/Bits/BitStruct const!'
return ConstInstance( signal, c )
# Get the base component
base_comp = cur_component
full_name = base_comp._dsl.full_name
my_name = base_comp._dsl.my_name
assert expr.find( full_name ) >= 0, \
f"cannot find the base of attribute {full_name} in {expr}"
# Start from the base component and process one operation per iteration
cur_pos, cur_node = 0, base_comp
while cur_pos < len( expr ):
op, next_pos = get_next_op( expr, cur_pos, my_name, full_name )
if op[0] == 'Done': break
cur_node = get_cls_inst( signal_expr_classes[ op[0] ], cur_node, op[1:] )
cur_pos = next_pos
return cur_node
except AssertionError as e:
msg = '' if e.args[0] is None else e.args[0]
raise RTLIRConversionError( signal, msg )