X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=scripts%2Fir_spec.py;h=0961109710edec56cd96f920af315cc9b6722c28;hb=8bced5f492333d7ac6080e8cb313da3aeef431ff;hp=7e8b2c1506e53b675914e815f41e2985da231190;hpb=296dfbcbe4da36ca193f81c60443dda80890fab4;p=libfirm

diff --git a/scripts/ir_spec.py b/scripts/ir_spec.py
index 7e8b2c150..096110971 100755
--- a/scripts/ir_spec.py
+++ b/scripts/ir_spec.py
@@ -1,37 +1,37 @@
-nodes = dict(
-
-#
-# Abstract node types
-#
-unop = dict(
-	abstract = True,
-	ins      = [ "op" ],
-	op_index = 0,
-),
-
-binop = dict(
-	abstract = True,
-	ins      = [ "left", "right" ],
-	op_index = 0,
-),
-
-#
-# 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 Add(Binop):
+	flags = ["commutative"]
+
+class Alloc(Op):
+	ins   = [ "mem", "count" ]
+	outs  = [
+		("M",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res",       "pointer to newly allocated memory",     "pn_Generic_other"),
+	]
+	flags = [ "fragile", "uses_memory" ]
 	attrs = [
 		dict(
 			name = "type",
@@ -41,35 +41,31 @@ Alloc = dict(
 			name = "where",
 			type = "ir_where_alloc"
 		)
-	],
-	pinned      = "yes",
-	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",
-	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   = "pinned",
+	]
+	pinned      = "yes"
+	attr_struct = "alloc_attr"
+
+class Anchor(Op):
+	mode        = "mode_ANY"
+	arity       = "variable"
+	flags       = [ "dump_noblock" ]
+	pinned      = "yes"
+	attr_struct = "irg_attr"
+	knownBlock  = True
+	singleton   = True
+	noconstructor = 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",
@@ -78,6 +74,7 @@ ASM = dict(
 		dict(
 			name = "n_output_constraints",
 			type = "int",
+			noprop = True,
 		),
 		dict(
 			name = "output_constraints",
@@ -86,6 +83,7 @@ ASM = dict(
 		dict(
 			name = "n_clobbers",
 			type = "int",
+			noprop = True,
 		),
 		dict(
 			name = "clobbers",
@@ -95,79 +93,54 @@ ASM = dict(
 			name = "text",
 			type = "ident*",
 		),
-	],
-	java_noconstr = True,
-),
-
-Bad = dict(
-	mode       = "mode_Bad",
-	flags      = "cfopcode, fragile, start_block, dump_noblock",
-	knownBlock = True,
-	singleton  = True,
-),
-
-Block = dict(
-	mode        = "mode_BB",
-	knownBlock  = True,
-	block       = "NULL",
-	optimize    = False,
-	arity       = "variable",
-	flags       = "labeled",
-	attr_struct = "block_attr",
-	java_noconstr = True,
-
+	]
+
+class Bad(Op):
+	mode          = "mode_T"
+	flags         = [ "cfopcode", "start_block", "dump_noblock" ]
+	pinned        = "yes"
+	knownBlock    = True
+	block         = "get_irg_start_block(irg)"
+	singleton     = True
+	attr_struct   = "bad_attr"
 	init = '''
-	/* macroblock header */
-	res->in[0] = res;
+	res->attr.bad.irg.irg = irg;
+	'''
 
-	res->attr.block.is_dead     = 0;
-	res->attr.block.is_mb_head  = 1;
-	res->attr.block.has_label   = 0;
-	res->attr.block.irg         = irg;
-	res->attr.block.backedge    = new_backedge_arr(irg->obst, arity);
-	res->attr.block.in_cg       = NULL;
-	res->attr.block.cg_backedge = NULL;
-	res->attr.block.extblk      = NULL;
-	res->attr.block.mb_depth    = 0;
-	res->attr.block.label       = 0;
+class Deleted(Op):
+	mode          = "mode_Bad"
+	flags         = [ ]
+	pinned        = "yes"
+	noconstructor = True
+
+class Block(Op):
+	mode        = "mode_BB"
+	knownBlock  = True
+	block       = "NULL"
+	pinned      = "yes"
+	arity       = "variable"
+	flags       = [ "labeled" ]
+	attr_struct = "block_attr"
 
+	init = '''
+	res->attr.block.irg.irg     = irg;
+	res->attr.block.backedge    = new_backedge_arr(irg->obst, arity);
 	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) {
-		binding_cons.add_immBlock_pred(ptr, node.ptr);
+		binding_ircons.add_immBlock_pred(ptr, node.ptr);
 	}
 
 	public void mature() {
-		binding_cons.mature_immBlock(ptr);
+		binding_ircons.mature_immBlock(ptr);
 	}
 
 	@Override
@@ -176,48 +149,43 @@ Block = dict(
 	}
 
 	public boolean blockVisited() {
-		return 0 != binding.Block_block_visited(ptr);
+		return 0 != binding_irnode.Block_block_visited(ptr);
 	}
 
 	public void markBlockVisited() {
-		binding.mark_Block_block_visited(ptr);
+		binding_irnode.mark_Block_block_visited(ptr);
 	}
 
 	public boolean isBad() {
-		return binding.is_Bad(ptr) != 0;
+		return binding_irnode.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 = "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",
-),
-
-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 Borrow(Binop):
+	flags = []
+
+class Bound(Op):
+	ins    = [ "mem", "index", "lower", "upper" ]
+	outs  = [
+		("M",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res",       "the checked index",                     "pn_Generic_other"),
+	]
+ 	flags  = [ "fragile", "highlevel" ]
+	pinned = "exception"
+	pinned_init = "op_pin_state_pinned"
+	attr_struct = "bound_attr"
+	attrs_name  = "bound"
+
+class Builtin(Op):
+	ins      = [ "mem" ]
+	arity    = "variable"
+	outs     = [
+		("M",        "memory result", "pn_Generic_M"),
+		("1_result", "first result",  "pn_Generic_other"),
+	]
+	flags    = [ "uses_memory" ]
 	attrs    = [
 		dict(
 			type = "ir_builtin_kind",
@@ -227,87 +195,89 @@ Builtin = dict(
 			type = "ir_type*",
 			name = "type"
 		)
-	],
-	pinned      = "memory",
-	pinned_init = "pinned",
+	]
+	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",                "memory result",                         "pn_Generic_M"),
+		("X_regular",        "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",         "control flow when exception occured",   "pn_Generic_X_except"),
+		("T_result",         "tuple containing all results",          "pn_Generic_other"),
+		("P_value_res_base", "pointer to memory register containing copied results passed by value"),
+	]
+	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 = "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",
-	# TODO: attribute with call...
-	attr_struct   = "callbegin_attr",
-	java_noconstr = True,
-	init = '''
-	res->attr.callbegin.call = call;
-	''',
-),
-
-Carry = dict(
-	is_a     = "binop",
-	flags    = "commutative",
-),
-
-Cast = dict(
-	ins      = [ "op" ],
-	mode     = "get_irn_mode(irn_op)",
-	flags    = "highlevel",
+
+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",
+
+class Cmp(Binop):
+	outs  = [
+		("False", "always false",                            "0"),
+		("Eq",    "equal",                                   "1"),
+		("Lt",    "less",                                    "2"),
+		("Le",    "less or equal",                           "pn_Cmp_Eq|pn_Cmp_Lt"),
+		("Gt",    "greater",                                 "4"),
+		("Ge",    "greater or equal",                        "pn_Cmp_Eq|pn_Cmp_Gt"),
+		("Lg",    "less or greater ('not equal' for integer numbers)", "pn_Cmp_Lt|pn_Cmp_Gt"),
+		("Leg",   "less, equal or greater ('not unordered')", "pn_Cmp_Lt|pn_Cmp_Eq|pn_Cmp_Gt"),
+		("Uo",    "unordered",                               "8"),
+		("Ue",    "unordered or equal",                      "pn_Cmp_Uo|pn_Cmp_Eq"),
+		("Ul",    "unordered or less",                       "pn_Cmp_Uo|pn_Cmp_Lt"),
+		("Ule",   "unordered, less or equal",                "pn_Cmp_Uo|pn_Cmp_Lt|pn_Cmp_Eq"),
+		("Ug",    "unordered or greater",                    "pn_Cmp_Uo|pn_Cmp_Gt"),
+		("Uge",   "onordered, greater or equal",             "pn_Cmp_Uo|pn_Cmp_Gt|pn_Cmp_Eq"),
+		("Ne",    "unordered, less or greater ('not equal' for floatingpoint numbers)", "pn_Cmp_Uo|pn_Cmp_Lt|pn_Cmp_Gt"),
+		("True",  "always true",                             "15"),
+	]
+	flags = []
+
+class Cond(Op):
+	ins      = [ "selector" ]
+	outs     = [
+		("false", "control flow if operand is \"false\""),
+		("true",  "control flow if operand is \"true\""),
+	]
+	flags    = [ "cfopcode", "forking" ]
+	pinned   = "yes"
 	attrs    = [
-		dict(
-			name = "kind",
-			type = "cond_kind",
-			init = "dense"
-		),
 		dict(
 			name = "default_proj",
 			type = "long",
@@ -318,40 +288,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",
+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,
-	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*",
+			type = "ir_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",
@@ -362,35 +331,39 @@ 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",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+	]
+	flags = [ "fragile", "highlevel", "uses_memory" ]
 	attrs = [
 		dict(
 			name = "type",
 			type = "ir_type*"
 		)
-	],
-	attr_struct = "copyb_attr",
-	pinned      = "memory",
-	pinned_init = "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",
+	]
+	attr_struct = "copyb_attr"
+	attrs_name  = "copyb"
+	pinned      = "memory"
+	pinned_init = "op_pin_state_pinned"
+
+class Div(Op):
+	ins   = [ "mem", "left", "right" ]
+	outs  = [
+		("M",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res",       "result of computation",                 "pn_Generic_other"),
+	]
+	flags = [ "fragile", "uses_memory" ]
+	attrs_name = "divmod"
 	attrs = [
 		dict(
 			type = "ir_mode*",
@@ -405,96 +378,59 @@ Div = dict(
 				init = "1"
 			)
 		)
-	],
-	attr_struct = "divmod_attr",
-	pinned      = "exception",
-	op_index    = 1,
-	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",
+	]
+	attr_struct = "divmod_attr"
+	pinned      = "exception"
+	op_index    = 1
+	arity_override = "oparity_binary"
+
+class DivMod(Op):
+	ins   = [ "mem", "left", "right" ]
+	outs  = [
+		("M",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res_div",   "result of computation a/b",             "pn_Generic_other"),
+		("res_mod",   "result of computation a%b"),
+	]
+	flags = [ "fragile", "uses_memory" ]
+	attrs_name = "divmod"
 	attrs = [
 		dict(
 			type = "ir_mode*",
 			name = "resmode"
 		),
-	],
-	attr_struct = "divmod_attr",
-	pinned      = "exception",
-	op_index    = 1,
-	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,
-	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"
-		)
-	],
-	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",
-	attrs = [
+	]
+	attr_struct = "divmod_attr"
+	pinned      = "exception"
+	op_index    = 1
+	arity_override = "oparity_binary"
+
+class Dummy(Op):
+	ins   = []
+	flags = [ "cfopcode", "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" ]
+	knownBlock = True
+	block      = "get_irg_end_block(irg)"
+	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",
 			type = "ir_type*"
@@ -503,285 +439,299 @@ Free = dict(
 			name = "where",
 			type = "ir_where_alloc"
 		)
-	],
-	attr_struct = "free_attr",
-),
-
-Id = dict(
-	ins   = [ "pred" ],
-	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",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res",       "checked object pointer",                "pn_Generic_other"),
+	]
+	flags = [ "highlevel" ]
 	attrs = [
 		dict(
 			name = "type",
 			type = "ir_type*"
 		)
-	],
-	attr_struct = "io_attr",
-	pinned      = "memory",
-	pinned_init = "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",
+	]
+	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",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res",       "result of load operation",              "pn_Generic_other"),
+	]
+	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",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res",       "result of computation",                 "pn_Generic_other"),
+	]
+	flags = [ "fragile", "uses_memory" ]
+	attrs_name = "divmod"
 	attrs = [
 		dict(
 			type = "ir_mode*",
 			name = "resmode"
 		),
-	],
-	attr_struct = "divmod_attr",
-	pinned      = "exception",
-	op_index    = 1,
-	d_post = '''
-	#if PRECISE_EXC_CONTEXT
-	firm_alloc_frag_arr(res, op_Mod, &res->attr.except.frag_arr);
-	#endif
+	]
+	attr_struct = "divmod_attr"
+	pinned      = "exception"
+	op_index    = 1
+	arity_override = "oparity_binary"
+
+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
+	block         = "get_irg_start_block(irg)"
+	singleton     = True
+
+class Not(Unop):
+	flags = []
+
+class Or(Binop):
+	flags = [ "commutative" ]
+
+class Phi(Op):
+	pinned        = "yes"
+	arity         = "variable"
+	flags         = []
+	attr_struct   = "phi_attr"
+	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);
 	'''
-),
-
-Mul = dict(
-	is_a     = "binop",
-	flags    = "commutative",
-),
-
-Mulh = dict(
-	is_a     = "binop",
-	flags    = "commutative",
-),
-
-Mux = dict(
-	ins   = [ "sel", "false", "true" ],
-	flags = "none",
-),
-
-NoMem = dict(
-	mode       = "mode_M",
-	flags      = "dump_noblock, dump_noinput",
-	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",
-),
-
-Proj = dict(
-	ins      = [ "pred" ],
-	flags    = "none",
-	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",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_X_except"),
+		("res",       "result of computation",                 "pn_Generic_other"),
+	]
+	flags = [ "fragile", "uses_memory" ]
+	attrs_name = "divmod"
 	attrs = [
 		dict(
 			type = "ir_mode*",
 			name = "resmode"
 		),
-	],
-	attr_struct = "divmod_attr",
-	pinned      = "exception",
-	op_index    = 1,
-	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",
-),
-
-Return = dict(
-	ins      = [ "mem" ],
-	arity    = "variable",
-	mode     = "mode_X",
-	flags    = "cfopcode",
-),
-
-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",
-	attrs    = [
+	]
+	attr_struct = "divmod_attr"
+	pinned      = "exception"
+	op_index    = 1
+	arity_override = "oparity_binary"
+
+class Raise(Op):
+	ins    = [ "mem", "exo_ptr" ]
+	outs  = [
+		("M", "memory result",                     "pn_Generic_M"),
+		("X", "control flow to exception handler", "pn_Generic_X_regular"),
+	]
+	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",
-	attr_struct = "store_attr",
+	]
+	attr_struct = "sel_attr"
+
+class Shl(Binop):
+	flags = []
+
+class Shr(Binop):
+	flags = []
+
+class Shrs(Binop):
+	flags = []
+
+class Start(Op):
+	outs       = [
+		("X_initial_exec", "control flow"),
+		("M",              "initial memory"),
+		("P_frame_base",   "frame base pointer"),
+		("P_tls",          "pointer to thread local storage segment"),
+		("T_args",         "function arguments")
+	]
+	mode       = "mode_T"
+	pinned     = "yes"
+	flags      = [ "cfopcode" ]
+	singleton  = True
+	knownBlock = True
+	block      = "get_irg_start_block(irg)"
+
+class Store(Op):
+	ins      = [ "mem", "ptr", "value" ]
+	outs  = [
+		("M",         "memory result",                         "pn_Generic_M"),
+		("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
+		("X_except",  "control flow when exception occured",   "pn_Generic_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",
-),
+class Sub(Binop):
+	flags = []
 
-SymConst = dict(
-	mode       = "mode_P",
-	flags      = "constlike, start_block",
-	knownBlock = True,
+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",
-	optimize = False,
+	]
+	attr_struct = "symconst_attr"
+
+class Sync(Op):
+	mode     = "mode_M"
+	flags    = []
+	pinned   = "no"
 	arity    = "dynamic"
-),
-
-Tuple = dict(
-	arity = "variable",
-	mode  = "mode_T",
-	flags = "labeled",
-	java_noconstr = True
-),
-
-Unknown = dict(
-	knownBlock = True,
-	block      = "get_irg_start_block(irg)",
-	flags      = "cfopcode, fragile, start_block, constlike, dump_noblock",
-),
-)
+
+class Tuple(Op):
+	arity  = "variable"
+	mode   = "mode_T"
+	pinned = "no"
+	flags  = [ "labeled" ]
+
+class Unknown(Op):
+	knownBlock = True
+	pinned     = "yes"
+	block      = "get_irg_start_block(irg)"
+	flags      = [ "cfopcode", "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))