-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", "size" ]
+ outs = [ "M", "X_regular", "X_except", "res" ]
+ flags = [ "fragile", "uses_memory" ]
attrs = [
dict(
name = "type",
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" ]
+ attr_struct = "asm_attr"
+ pinned = "memory"
+ pinned_init = "op_pin_state_pinned"
attrs = [
dict(
name = "input_constraints",
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 */
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;
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. */
current_ir_graph->current_block = res;
IRN_VRFY_IRG(res, current_ir_graph);
- ''',
+ '''
java_add = '''
public void addPred(Node node) {
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"
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 Break(Op):
+ mode = "mode_X"
+ flags = [ "cfopcode" ]
+ pinned = "yes"
+
+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",
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",
+class CallBegin(Op):
+ ins = [ "ptr" ]
+ outs = [ "" ] # TODO
+ flags = [ "cfopcode", "ip_cfopcode" ]
+ pinned = "yes"
# TODO: attribute with call...
- attr_struct = "callbegin_attr",
+ 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",
+ ]
+ java_noconstr = True
+
+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", "Eq", "Lt", "Le", "Gt", "Ge", "Lg", "Leg", "Uo", "Ue", "Ul", "Ule", "Ug", "Uge", "Ne", "True" ]
+ flags = []
+
+class Cond(Op):
+ ins = [ "selector" ]
+ outs = [ "false", "true" ]
+ flags = [ "cfopcode", "forking" ]
+ pinned = "yes"
attrs = [
dict(
name = "kind",
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"
+
+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",
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"
+
+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"
+ 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*",
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",
+
+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 EndExcept(Op):
+ 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",
+class EndReg(Op):
+ mode = "mode_X"
+ pinned = "yes"
+ arity = "dynamic"
+ flags = [ "cfopcode", "ip_cfopcode" ]
singleton = True
-),
-Eor = dict(
- is_a = "binop",
- flags = "commutative",
-),
+class Eor(Binop):
+ flags = [ "commutative" ]
-Filter = dict(
- ins = [ "pred" ],
- flags = "none",
+class Filter(Op):
+ ins = [ "pred" ]
+ flags = []
attrs = [
dict(
name = "proj",
type = "long"
)
- ],
- pinned = "yes",
- attr_struct = "filter_attr",
+ ]
+ 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 Free(Op):
+ ins = [ "mem", "ptr", "size" ]
+ mode = "mode_M"
+ flags = [ "uses_memory" ]
+ pinned = "yes"
attrs = [
dict(
name = "type",
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,
-),
-
-Pin = dict(
- ins = [ "op" ],
- mode = "get_irn_mode(irn_op)",
- flags = "highlevel",
- pinned = "yes",
-),
-
-Proj = dict(
- ins = [ "pred" ],
- flags = "none",
- pinned = "no",
+
+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"
+ custom_is = True
+ 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);
+ '''
+
+class Pin(Op):
+ ins = [ "op" ]
+ mode = "get_irn_mode(irn_op)"
+ flags = [ "highlevel" ]
+ pinned = "yes"
+
+class Proj(Op):
+ ins = [ "pred" ]
+ flags = []
+ pinned = "no"
attrs = [
dict(
type = "long",
name = "proj",
initname = ""
)
- ],
- 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"
+ custom_is = True
+
+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"
)
- ],
- 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))
projects / libfirm / blobdiff