X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=scripts%2Fir_spec.py;h=a843b185b172e5083eec782025f7d690adbea548;hb=1de9ff0cca036132747eb5dbca17afde02e4fb65;hp=ac7e0bd5028bb3f1893a959d63d4c2d7a7186454;hpb=1a68ac345360bd542a3a459e46171e9ca50fc850;p=libfirm diff --git a/scripts/ir_spec.py b/scripts/ir_spec.py index ac7e0bd50..a843b185b 100755 --- a/scripts/ir_spec.py +++ b/scripts/ir_spec.py @@ -1,39 +1,35 @@ -nodes = dict( - -# -# Abstract node types -# -unop = dict( - abstract = True, - ins = [ "op" ], - op_index = 0, - pinned = "no", -), - -binop = dict( - abstract = True, - ins = [ "left", "right" ], - op_index = 0, - pinned = "no", -), - -# -# Real node types -# -Abs = dict( - is_a = "unop", - flags = "none", -), - -Add = dict( - is_a = "binop", - flags = "commutative", -), - -Alloc = dict( - ins = [ "mem", "size" ], - outs = [ "M", "X_regular", "X_except", "res" ], - flags = "fragile, uses_memory", +from spec_util import abstract, setnodedefaults + +class Op(object): + "Base class for firm nodes" +abstract(Op) + +class Unop(Op): + "Unary nodes have exactly 1 input" + name = "unop" + ins = [ "op" ] + op_index = 0 + pinned = "no" +abstract(Unop) + +class Binop(Op): + "Binary nodes have exactly 2 inputs" + name = "binop" + ins = [ "left", "right" ] + op_index = 0 + pinned = "no" +abstract(Binop) + +class Abs(Unop): + flags = [] + +class Add(Binop): + flags = ["commutative"] + +class Alloc(Op): + ins = [ "mem", "count" ] + outs = [ "M", "X_regular", "X_except", "res" ] + flags = [ "fragile", "uses_memory" ] attrs = [ dict( name = "type", @@ -43,37 +39,32 @@ Alloc = dict( name = "where", type = "ir_where_alloc" ) - ], - pinned = "yes", - attr_struct = "alloc_attr", + ] + pinned = "yes" + attr_struct = "alloc_attr" d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Alloc, &res->attr.alloc.exc.frag_arr); - #endif ''' -), - -Anchor = dict( - mode = "mode_ANY", - arity = "variable", - flags = "dump_noblock", - pinned = "yes", - knownBlock = True, - singleton = True, -), - -And = dict( - is_a = "binop", - flags = "commutative", -), - -ASM = dict( - mode = "mode_T", - arity = "variable", - flags = "keep, uses_memory", - attr_struct = "asm_attr", - pinned = "memory", - pinned_init = "op_pin_state_pinned", + +class Anchor(Op): + mode = "mode_ANY" + arity = "variable" + flags = [ "dump_noblock" ] + pinned = "yes" + knownBlock = True + singleton = True + +class And(Binop): + flags = [ "commutative" ] + +class ASM(Op): + mode = "mode_T" + arity = "variable" + flags = [ "keep", "uses_memory" ] + pinned = "memory" + pinned_init = "op_pin_state_pinned" + attr_struct = "asm_attr" + attrs_name = "assem" attrs = [ dict( name = "input_constraints", @@ -82,6 +73,7 @@ ASM = dict( dict( name = "n_output_constraints", type = "int", + noprop = True, ), dict( name = "output_constraints", @@ -90,6 +82,7 @@ ASM = dict( dict( name = "n_clobbers", type = "int", + noprop = True, ), dict( name = "clobbers", @@ -99,28 +92,30 @@ ASM = dict( name = "text", type = "ident*", ), - ], - java_noconstr = True, -), - -Bad = dict( - mode = "mode_Bad", - flags = "cfopcode, fragile, start_block, dump_noblock", - pinned = "yes", - knownBlock = True, - singleton = True, -), - -Block = dict( - mode = "mode_BB", - knownBlock = True, - block = "NULL", - pinned = "yes", - optimize = False, - arity = "variable", - flags = "labeled", - attr_struct = "block_attr", - java_noconstr = True, + ] + java_noconstr = True + +class Bad(Op): + mode = "mode_Bad" + flags = [ "cfopcode", "fragile", "start_block", "dump_noblock" ] + pinned = "yes" + knownBlock = True + singleton = True + attr_struct = "irg_attr" + init = ''' + res->attr.irg.irg = irg; + ''' + +class Block(Op): + mode = "mode_BB" + knownBlock = True + block = "NULL" + pinned = "yes" + optimize = False + arity = "variable" + flags = [ "labeled" ] + attr_struct = "block_attr" + java_noconstr = True init = ''' /* macroblock header */ @@ -128,7 +123,7 @@ Block = dict( res->attr.block.is_dead = 0; res->attr.block.is_mb_head = 1; - res->attr.block.irg = irg; + res->attr.block.irg.irg = irg; res->attr.block.backedge = new_backedge_arr(irg->obst, arity); res->attr.block.in_cg = NULL; res->attr.block.cg_backedge = NULL; @@ -138,33 +133,13 @@ Block = dict( set_Block_matured(res, 1); set_Block_block_visited(res, 0); - ''', - - d_pre = ''' - int i; - int has_unknown = 0; - ''', - d_post = ''' /* Create and initialize array for Phi-node construction. */ - if (get_irg_phase_state(current_ir_graph) == phase_building) { - res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, - current_ir_graph->n_loc); - memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc); + if (get_irg_phase_state(irg) == phase_building) { + res->attr.block.graph_arr = NEW_ARR_D(ir_node *, irg->obst, irg->n_loc); + memset(res->attr.block.graph_arr, 0, irg->n_loc * sizeof(ir_node*)); } - - for (i = arity - 1; i >= 0; i--) - if (is_Unknown(in[i])) { - has_unknown = 1; - break; - } - - if (!has_unknown) res = optimize_node(res); - - current_ir_graph->current_block = res; - - IRN_VRFY_IRG(res, current_ir_graph); - ''', + ''' java_add = ''' public void addPred(Node node) { @@ -191,39 +166,28 @@ Block = dict( public boolean isBad() { return binding.is_Bad(ptr) != 0; } - ''', -), - -Borrow = dict( - is_a = "binop", - flags = "none", -), - -Bound = dict( - ins = [ "mem", "index", "lower", "upper" ], - outs = [ "M", "X_regular", "X_except", "res" ], - flags = "fragile, highlevel", - pinned = "exception", - pinned_init = "op_pin_state_pinned", - attr_struct = "bound_attr", + ''' + +class Borrow(Binop): + flags = [] + +class Bound(Op): + ins = [ "mem", "index", "lower", "upper" ] + outs = [ "M", "X_regular", "X_except", "res" ] + flags = [ "fragile", "highlevel" ] + pinned = "exception" + pinned_init = "op_pin_state_pinned" + attr_struct = "bound_attr" + attrs_name = "bound" d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Bound, &res->attr.bound.exc.frag_arr); - #endif ''' -), - -Break = dict( - mode = "mode_X", - flags = "cfopcode", - pinned = "yes", -), - -Builtin = dict( - ins = [ "mem" ], - arity = "variable", - outs = [ "M_regular", "X_regular", "X_except", "T_result", "M_except", "P_value_res_base" ], - flags = "uses_memory", + +class Builtin(Op): + ins = [ "mem" ] + arity = "variable" + outs = [ "M", "X_regular", "X_except", "T_result", "P_value_res_base" ] + flags = [ "uses_memory" ] attrs = [ dict( type = "ir_builtin_kind", @@ -233,94 +197,83 @@ Builtin = dict( type = "ir_type*", name = "type" ) - ], - pinned = "memory", - pinned_init = "op_pin_state_pinned", - attr_struct = "builtin_attr", + ] + pinned = "memory" + pinned_init = "op_pin_state_pinned" + attr_struct = "builtin_attr" init = ''' assert((get_unknown_type() == type) || is_Method_type(type)); ''' - # TODO: No firm_alloc_frag_arr?? -), - -Call = dict( - ins = [ "mem", "ptr" ], - arity = "variable", - outs = [ "M_regular", "X_regular", "X_except", "T_result", "M_except", "P_value_res_base" ], - flags = "fragile, uses_memory", +class Call(Op): + ins = [ "mem", "ptr" ] + arity = "variable" + outs = [ "M", "X_regular", "X_except", "T_result", "P_value_res_base" ] + flags = [ "fragile", "uses_memory" ] attrs = [ dict( type = "ir_type*", name = "type" + ), + dict( + type = "unsigned", + name = "tail_call", + # the tail call attribute can only be set by analysis + init = "0" ) - ], - attr_struct = "call_attr", - pinned = "memory", - pinned_init = "op_pin_state_pinned", + ] + attr_struct = "call_attr" + pinned = "memory" + pinned_init = "op_pin_state_pinned" init = ''' assert((get_unknown_type() == type) || is_Method_type(type)); - ''', + ''' d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr); - #endif ''' -), - -CallBegin = dict( - ins = [ "ptr" ], - outs = [ "" ], # TODO - flags = "cfopcode, ip_cfopcode", - pinned = "yes", - # TODO: attribute with call... - attr_struct = "callbegin_attr", - attrs = [ - dict( - type = "ir_node*", - name = "call" - ) - ], - java_noconstr = True, -), - -Carry = dict( - is_a = "binop", - flags = "commutative", -), - -Cast = dict( - ins = [ "op" ], - mode = "get_irn_mode(irn_op)", - flags = "highlevel", - pinned = "no", + +class Carry(Binop): + flags = [ "commutative" ] + +class Cast(Unop): + mode = "get_irn_mode(irn_op)" + flags = [ "highlevel" ] attrs = [ dict( type = "ir_type*", name = "type" ) - ], - attr_struct = "cast_attr", + ] + attr_struct = "cast_attr" init = "assert(is_atomic_type(type));" -), - -Cmp = dict( - is_a = "binop", - outs = [ "False", "Eq", "Lt", "Le", "Gt", "Ge", "Lg", "Leg", "Uo", "Ue", "Ul", "Ule", "Ug", "Uge", "Ne", "True" ], - flags = "none", -), - -Cond = dict( - ins = [ "selector" ], - outs = [ "false", "true" ], - flags = "cfopcode, forking", - pinned = "yes", + +class Cmp(Binop): + outs = [ + ("False", "always false"), + ("Eq", "equal"), + ("Lt", "less"), + ("Le", "less or equal"), + ("Gt", "greater"), + ("Ge", "greater or equal"), + ("Lg", "less or greater"), + ("Leg", "less, equal or greater ('not equal' for integer numbers)"), + ("Uo", "unordered"), + ("Ue", "unordered or equal"), + ("Ul", "unordered or less"), + ("Ule", "unordered, less or equal"), + ("Ug", "unordered or greater"), + ("Uge", "onordered, greater or equal"), + ("Ne", "unordered, less, greater or equal ('not equal' for floatingpoint numbers)"), + ("True", "always true"), + ] + flags = [] + +class Cond(Op): + ins = [ "selector" ] + outs = [ "false", "true" ] + flags = [ "cfopcode", "forking" ] + pinned = "yes" attrs = [ - dict( - name = "kind", - type = "cond_kind", - init = "dense" - ), dict( name = "default_proj", type = "long", @@ -331,42 +284,39 @@ Cond = dict( type = "cond_jmp_predicate", init = "COND_JMP_PRED_NONE" ) - ], + ] attr_struct = "cond_attr" -), -Confirm = dict( - ins = [ "value", "bound" ], - mode = "get_irn_mode(irn_value)", - flags = "highlevel", - pinned = "yes", +class Confirm(Op): + ins = [ "value", "bound" ] + mode = "get_irn_mode(irn_value)" + flags = [ "highlevel" ] + pinned = "yes" attrs = [ dict( name = "cmp", type = "pn_Cmp" ), - ], - attr_struct = "confirm_attr", -), - -Const = dict( - mode = "", - flags = "constlike, start_block", - knownBlock = True, - pinned = "no", - attrs_name = "con", + ] + attr_struct = "confirm_attr" + attrs_name = "confirm" + +class Const(Op): + mode = "" + flags = [ "constlike", "start_block" ] + knownBlock = True + pinned = "no" + attrs_name = "con" attrs = [ dict( type = "tarval*", name = "tarval", ) - ], - attr_struct = "const_attr", -), + ] + attr_struct = "const_attr" -Conv = dict( - is_a = "unop", - flags = "none", +class Conv(Unop): + flags = [] attrs = [ dict( name = "strict", @@ -377,35 +327,33 @@ Conv = dict( init = "1" ) ) - ], - attr_struct = "conv_attr", -), - -CopyB = dict( - ins = [ "mem", "dst", "src" ], - outs = [ "M", "X_regular", "X_except" ], - flags = "fragile, highlevel, uses_memory", + ] + attr_struct = "conv_attr" + attrs_name = "conv" + +class CopyB(Op): + ins = [ "mem", "dst", "src" ] + outs = [ "M", "X_regular", "X_except" ] + flags = [ "fragile", "highlevel", "uses_memory" ] attrs = [ dict( name = "type", type = "ir_type*" ) - ], - attr_struct = "copyb_attr", - pinned = "memory", - pinned_init = "op_pin_state_pinned", + ] + attr_struct = "copyb_attr" + attrs_name = "copyb" + pinned = "memory" + pinned_init = "op_pin_state_pinned" d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_CopyB, &res->attr.copyb.exc.frag_arr); - #endif ''' -), -Div = dict( - ins = [ "mem", "left", "right" ], - outs = [ "M", "X_regular", "X_except", "res" ], - flags = "fragile, uses_memory", - attrs_name = "divmod", +class Div(Op): + ins = [ "mem", "left", "right" ] + outs = [ "M", "X_regular", "X_except", "res" ] + flags = [ "fragile", "uses_memory" ] + attrs_name = "divmod" attrs = [ dict( type = "ir_mode*", @@ -420,100 +368,57 @@ Div = dict( init = "1" ) ) - ], - attr_struct = "divmod_attr", - pinned = "exception", - op_index = 1, - arity_override = "oparity_binary", + ] + attr_struct = "divmod_attr" + pinned = "exception" + op_index = 1 + arity_override = "oparity_binary" d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Div, &res->attr.except.frag_arr); - #endif ''' -), -DivMod = dict( - ins = [ "mem", "left", "right" ], - outs = [ "M", "X_regular", "X_except", "res_div", "res_mod" ], - flags = "fragile, uses_memory", - attrs_name = "divmod", +class DivMod(Op): + ins = [ "mem", "left", "right" ] + outs = [ "M", "X_regular", "X_except", "res_div", "res_mod" ] + flags = [ "fragile", "uses_memory" ] + attrs_name = "divmod" attrs = [ dict( type = "ir_mode*", name = "resmode" ), - ], - attr_struct = "divmod_attr", - pinned = "exception", - op_index = 1, - arity_override = "oparity_binary", + ] + attr_struct = "divmod_attr" + pinned = "exception" + op_index = 1 + arity_override = "oparity_binary" d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_DivMod, &res->attr.except.frag_arr); - #endif ''' -), - -Dummy = dict( - ins = [], - flags = "cfopcode, fragile, start_block, constlike, dump_noblock", - knownBlock = True, - pinned = "yes", - block = "get_irg_start_block(irg)", -), - -End = dict( - mode = "mode_X", - pinned = "yes", - arity = "dynamic", - flags = "cfopcode", - singleton = True, -), - -EndExcept = dict( - mode = "mode_X", - pinned = "yes", - arity = "dynamic", - flags = "cfopcode, ip_cfopcode", - singleton = True -), - -EndReg = dict( - mode = "mode_X", - pinned = "yes", - arity = "dynamic", - flags = "cfopcode, ip_cfopcode", - singleton = True -), - -Eor = dict( - is_a = "binop", - flags = "commutative", -), - -Filter = dict( - ins = [ "pred" ], - flags = "none", - attrs = [ - dict( - name = "proj", - type = "long" - ) - ], - pinned = "yes", - attr_struct = "filter_attr", - java_noconstr = True - # TODO: Broken asserts in original: - # assert(get_Proj_pred(res)); - # assert(get_nodes_block(get_Proj_pred(res))); -), - -Free = dict( - ins = [ "mem", "ptr", "size" ], - mode = "mode_M", - flags = "uses_memory", - pinned = "yes", +class Dummy(Op): + ins = [] + flags = [ "cfopcode", "fragile", "start_block", "constlike", + "dump_noblock" ] + knownBlock = True + pinned = "yes" + block = "get_irg_start_block(irg)" + +class End(Op): + mode = "mode_X" + pinned = "yes" + arity = "dynamic" + flags = [ "cfopcode" ] + singleton = True + +class Eor(Binop): + flags = [ "commutative" ] + +class Free(Op): + ins = [ "mem", "ptr", "size" ] + mode = "mode_M" + flags = [ "uses_memory" ] + pinned = "yes" attrs = [ dict( name = "type", @@ -523,310 +428,279 @@ Free = dict( name = "where", type = "ir_where_alloc" ) - ], - attr_struct = "free_attr", -), - -Id = dict( - ins = [ "pred" ], - pinned = "no", - flags = "none", -), - -IJmp = dict( - mode = "mode_X", - pinned = "yes", - ins = [ "target" ], - flags = "cfopcode, forking, keep", -), - -InstOf = dict( - ins = [ "store", "obj" ], - outs = [ "M", "X_regular", "X_except", "res", "M_except" ], - flags = "highlevel", + ] + attr_struct = "free_attr" + +class Id(Op): + ins = [ "pred" ] + pinned = "no" + flags = [] + +class IJmp(Op): + mode = "mode_X" + pinned = "yes" + ins = [ "target" ] + flags = [ "cfopcode", "forking", "keep" ] + +class InstOf(Op): + ins = [ "store", "obj" ] + outs = [ "M", "X_regular", "X_except", "res" ] + flags = [ "highlevel" ] attrs = [ dict( name = "type", type = "ir_type*" ) - ], - attr_struct = "io_attr", - pinned = "memory", - pinned_init = "op_pin_state_floats", -), - -Jmp = dict( - mode = "mode_X", - pinned = "yes", - ins = [], - flags = "cfopcode", -), - -Load = dict( - ins = [ "mem", "ptr" ], - outs = [ "M", "X_regular", "X_except", "res" ], - flags = "fragile, uses_memory", - pinned = "exception", - pinned_init = "flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned", + ] + attr_struct = "io_attr" + pinned = "memory" + pinned_init = "op_pin_state_floats" + +class Jmp(Op): + mode = "mode_X" + pinned = "yes" + ins = [] + flags = [ "cfopcode" ] + +class Load(Op): + ins = [ "mem", "ptr" ] + outs = [ "M", "X_regular", "X_except", "res" ] + flags = [ "fragile", "uses_memory" ] + pinned = "exception" + pinned_init = "flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned" attrs = [ dict( type = "ir_mode*", name = "mode", java_name = "load_mode" ), - ], - attr_struct = "load_attr", + ] + attr_struct = "load_attr" constructor_args = [ dict( type = "ir_cons_flags", name = "flags", ), - ], + ] d_post = ''' -#if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr); -#endif ''' -), - -Minus = dict( - is_a = "unop", - flags = "none", -), - -Mod = dict( - ins = [ "mem", "left", "right" ], - outs = [ "M", "X_regular", "X_except", "res" ], - flags = "fragile, uses_memory", - attrs_name = "divmod", + +class Minus(Unop): + flags = [] + +class Mod(Op): + ins = [ "mem", "left", "right" ] + outs = [ "M", "X_regular", "X_except", "res" ] + flags = [ "fragile", "uses_memory" ] + attrs_name = "divmod" attrs = [ dict( type = "ir_mode*", name = "resmode" ), - ], - attr_struct = "divmod_attr", - pinned = "exception", - op_index = 1, - arity_override = "oparity_binary", + ] + attr_struct = "divmod_attr" + pinned = "exception" + op_index = 1 + arity_override = "oparity_binary" d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Mod, &res->attr.except.frag_arr); - #endif ''' -), - -Mul = dict( - is_a = "binop", - flags = "commutative", -), - -Mulh = dict( - is_a = "binop", - flags = "commutative", -), - -Mux = dict( - ins = [ "sel", "false", "true" ], - flags = "none", - pinned = "no", -), - -NoMem = dict( - mode = "mode_M", - flags = "dump_noblock, dump_noinput", - pinned = "yes", - knownBlock = True, - singleton = True, -), - -Not = dict( - is_a = "unop", - flags = "none", -), - -Or = dict( - is_a = "binop", - flags = "commutative", -), - -Phi = dict( - pinned = "yes", - arity = "variable", - flags = "none", - attr_struct = "phi_attr", - custom_is = True, - java_noconstr = True, +class Mul(Binop): + flags = [ "commutative" ] + +class Mulh(Binop): + flags = [ "commutative" ] + +class Mux(Op): + ins = [ "sel", "false", "true" ] + flags = [] + pinned = "no" + +class NoMem(Op): + mode = "mode_M" + flags = [ "dump_noblock", "dump_noinput" ] + pinned = "yes" + knownBlock = True + singleton = True + +class Not(Unop): + flags = [] + +class Or(Binop): + flags = [ "commutative" ] + +class Phi(Op): + pinned = "yes" + arity = "variable" + flags = [] + attr_struct = "phi_attr" + java_noconstr = True init = ''' /* Memory Phis in endless loops must be kept alive. As we can't distinguish these easily we keep all of them alive. */ if (is_Phi(res) && mode == mode_M) add_End_keepalive(get_irg_end(irg), res); ''' -), - -Pin = dict( - ins = [ "op" ], - mode = "get_irn_mode(irn_op)", - flags = "highlevel", - pinned = "yes", -), - -Proj = dict( - ins = [ "pred" ], - flags = "none", - pinned = "no", - attrs = [ + +class Pin(Op): + ins = [ "op" ] + mode = "get_irn_mode(irn_op)" + flags = [ "highlevel" ] + pinned = "yes" + +class Proj(Op): + ins = [ "pred" ] + flags = [] + pinned = "no" + knownBlock = True + knownGraph = True + block = "get_nodes_block(irn_pred)" + graph = "get_irn_irg(irn_pred)" + attrs = [ dict( type = "long", name = "proj", - initname = "" + initname = "", + noprop = False, ) - ], - attr_struct = "long", - custom_is = True, -), - -Quot = dict( - ins = [ "mem", "left", "right" ], - outs = [ "M", "X_regular", "X_except", "res" ], - flags = "fragile, uses_memory", - attrs_name = "divmod", + ] + attr_struct = "long" + +class Quot(Op): + ins = [ "mem", "left", "right" ] + outs = [ "M", "X_regular", "X_except", "res" ] + flags = [ "fragile", "uses_memory" ] + attrs_name = "divmod" attrs = [ dict( type = "ir_mode*", name = "resmode" ), - ], - attr_struct = "divmod_attr", - pinned = "exception", - op_index = 1, - arity_override = "oparity_binary", + ] + attr_struct = "divmod_attr" + pinned = "exception" + op_index = 1 + arity_override = "oparity_binary" d_post = ''' - #if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Quot, &res->attr.except.frag_arr); - #endif ''' -), - -Raise = dict( - ins = [ "mem", "exo_ptr" ], - outs = [ "M", "X" ], - flags = "highlevel, cfopcode", - pinned = "yes", -), - -Return = dict( - ins = [ "mem" ], - arity = "variable", - mode = "mode_X", - flags = "cfopcode", - pinned = "yes", -), - -Rotl = dict( - is_a = "binop", - flags = "none", -), - -Sel = dict( - ins = [ "mem", "ptr" ], - arity = "variable", - flags = "none", - mode = "is_Method_type(get_entity_type(entity)) ? mode_P_code : mode_P_data", - pinned = "no", + +class Raise(Op): + ins = [ "mem", "exo_ptr" ] + outs = [ "M", "X" ] + flags = [ "highlevel", "cfopcode" ] + pinned = "yes" + +class Return(Op): + ins = [ "mem" ] + arity = "variable" + mode = "mode_X" + flags = [ "cfopcode" ] + pinned = "yes" + +class Rotl(Binop): + flags = [] + +class Sel(Op): + ins = [ "mem", "ptr" ] + arity = "variable" + flags = [] + mode = "is_Method_type(get_entity_type(entity)) ? mode_P_code : mode_P_data" + pinned = "no" attrs = [ dict( type = "ir_entity*", name = "entity" ) - ], - attr_struct = "sel_attr", -), - -Shl = dict( - is_a = "binop", - flags = "none", -), - -Shr = dict( - is_a = "binop", - flags = "none", -), - -Shrs = dict( - is_a = "binop", - flags = "none", -), - -Start = dict( - mode = "mode_T", - pinned = "yes", - flags = "cfopcode", - singleton = True, -), - -Store = dict( - ins = [ "mem", "ptr", "value" ], - outs = [ "M", "X_regular", "X_except" ], - flags = "fragile, uses_memory", - pinned = "exception", - attr_struct = "store_attr", - pinned_init = "flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned", + ] + attr_struct = "sel_attr" + +class Shl(Binop): + flags = [] + +class Shr(Binop): + flags = [] + +class Shrs(Binop): + flags = [] + +class Start(Op): + mode = "mode_T" + pinned = "yes" + flags = [ "cfopcode" ] + singleton = True + +class Store(Op): + ins = [ "mem", "ptr", "value" ] + outs = [ "M", "X_regular", "X_except" ] + flags = [ "fragile", "uses_memory" ] + pinned = "exception" + attr_struct = "store_attr" + pinned_init = "flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned" constructor_args = [ dict( type = "ir_cons_flags", name = "flags", ), - ], + ] d_post = ''' -#if PRECISE_EXC_CONTEXT firm_alloc_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr); -#endif ''' -), - -Sub = dict( - is_a = "binop", - flags = "none", -), - -SymConst = dict( - mode = "mode_P", - flags = "constlike, start_block", - knownBlock = True, - pinned = "no", + +class Sub(Binop): + flags = [] + +class SymConst(Op): + mode = "mode_P" + flags = [ "constlike", "start_block" ] + knownBlock = True + pinned = "no" attrs = [ dict( type = "ir_entity*", - name = "entity" + name = "entity", + noprop = True ) - ], - attr_struct = "symconst_attr", - java_noconstr = True, -), - -Sync = dict( - mode = "mode_M", - flags = "none", - pinned = "no", - optimize = False, + ] + attr_struct = "symconst_attr" + java_noconstr = True + +class Sync(Op): + mode = "mode_M" + flags = [] + pinned = "no" + optimize = False arity = "dynamic" -), -Tuple = dict( - arity = "variable", - mode = "mode_T", - pinned = "no", - flags = "labeled", +class Tuple(Op): + arity = "variable" + mode = "mode_T" + pinned = "no" + flags = [ "labeled" ] java_noconstr = True -), - -Unknown = dict( - knownBlock = True, - pinned = "yes", - block = "get_irg_start_block(irg)", - flags = "cfopcode, fragile, start_block, constlike, dump_noblock", -), -) + +class Unknown(Op): + knownBlock = True + pinned = "yes" + block = "get_irg_start_block(irg)" + flags = [ "cfopcode", "fragile", "start_block", "constlike", + "dump_noblock" ] + +# Prepare node list + +def getOpList(namespace): + nodes = [] + for t in namespace.values(): + if type(t) != type: + continue + + if issubclass(t, Op): + setnodedefaults(t) + nodes.append(t) + return nodes + +nodes = getOpList(globals()) +nodes = sorted(nodes, lambda x,y: cmp(x.name, y.name))