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 )