X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=e81e21266a22b711d9adaeb05700a558e3e4b020;hb=203717b8dd44597fb10c126b33a28528a2432e9c;hp=f4d51d82f355722255256bf222aa80ca46667200;hpb=b519dd6a1e6d85e843eff533be787d1f138a07ff;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index f4d51d82f..e81e21266 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -282,7 +282,7 @@ ir_node *
 }
 
 void
-set_irn_n(ir_node *node, int n, ir_node *in) {
+set_irn_n (ir_node *node, int n, ir_node *in) {
 	assert(node && node->kind == k_ir_node);
 	assert(-1 <= n);
 	assert(n < get_irn_arity(node));
@@ -316,7 +316,8 @@ set_irn_n(ir_node *node, int n, ir_node *in) {
 	node->in[n + 1] = in;
 }
 
-int add_irn_n(ir_node *node, ir_node *in) {
+int add_irn_n(ir_node *node, ir_node *in)
+{
 	int pos;
 	ir_graph *irg = get_irn_irg(node);
 
@@ -332,21 +333,25 @@ int add_irn_n(ir_node *node, ir_node *in) {
 }
 
 int
-(get_irn_deps)(const ir_node *node) {
+(get_irn_deps)(const ir_node *node)
+{
 	return _get_irn_deps(node);
 }
 
 ir_node *
-(get_irn_dep)(const ir_node *node, int pos) {
+(get_irn_dep)(const ir_node *node, int pos)
+{
 	return _get_irn_dep(node, pos);
 }
 
 void
-(set_irn_dep)(ir_node *node, int pos, ir_node *dep) {
+(set_irn_dep)(ir_node *node, int pos, ir_node *dep)
+{
 	_set_irn_dep(node, pos, dep);
 }
 
-int add_irn_dep(ir_node *node, ir_node *dep) {
+int add_irn_dep(ir_node *node, ir_node *dep)
+{
 	int res = 0;
 
 	if (node->deps == NULL) {
@@ -646,14 +651,24 @@ int get_irn_pred_pos(ir_node *node, ir_node *arg) {
 
 /** manipulate fields of individual nodes **/
 
+/* this works for all except Block */
 ir_node *
-(get_nodes_block)(const ir_node *node) {
-	return _get_nodes_block(node);
+get_nodes_block(const ir_node *node) {
+	assert(node->op != op_Block);
+	return get_irn_n(node, -1);
 }
 
 void
 set_nodes_block(ir_node *node, ir_node *block) {
-	node->op->ops.set_block(node, block);
+	assert(node->op != op_Block);
+	set_irn_n(node, -1, block);
+}
+
+/* this works for all except Block */
+ir_node *
+get_nodes_MacroBlock(const ir_node *node) {
+	assert(node->op != op_Block);
+	return get_Block_MacroBlock(get_irn_n(node, -1));
 }
 
 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
@@ -718,7 +733,7 @@ int
 }
 
 ir_node *
-(get_Block_cfgpred)(ir_node *node, int pos) {
+(get_Block_cfgpred)(const ir_node *node, int pos) {
 	return _get_Block_cfgpred(node, pos);
 }
 
@@ -729,12 +744,12 @@ set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
 }
 
 ir_node  *
-(get_Block_cfgpred_block)(ir_node *node, int pos) {
+(get_Block_cfgpred_block)(const ir_node *node, int pos) {
 	return _get_Block_cfgpred_block(node, pos);
 }
 
 int
-get_Block_matured(ir_node *node) {
+get_Block_matured(const ir_node *node) {
 	assert(node->op == op_Block);
 	return (int)node->attr.block.is_matured;
 }
@@ -783,6 +798,7 @@ set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
 	node->attr.block.graph_arr[pos+1] = value;
 }
 
+#ifdef INTERPROCEDURAL_VIEW
 void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) {
 	assert(node->op == op_Block);
 	if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
@@ -827,6 +843,7 @@ void remove_Block_cg_cfgpred_arr(ir_node *node) {
 	assert(node->op == op_Block);
 	node->attr.block.in_cg = NULL;
 }
+#endif
 
 ir_node *(set_Block_dead)(ir_node *block) {
 	return _set_Block_dead(block);
@@ -852,8 +869,13 @@ void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
 
 /* returns the macro block header of a block. */
 ir_node *get_Block_MacroBlock(const ir_node *block) {
+	ir_node *mbh;
 	assert(is_Block(block));
-	return get_irn_n(block, -1);
+	mbh = get_irn_n(block, -1);
+	/* once macro block header is respected by all optimizations,
+	   this assert can be removed */
+	assert(mbh != NULL);
+	return mbh;
 }
 
 /* returns the graph of a Block. */
@@ -862,6 +884,22 @@ ir_graph *get_Block_irg(const ir_node *block) {
 	return block->attr.block.irg;
 }
 
+int has_Block_label(const ir_node *block) {
+	assert(is_Block(block));
+	return block->attr.block.has_label;
+}
+
+ir_label_t get_Block_label(const ir_node *block) {
+	assert(is_Block(block));
+	return block->attr.block.label;
+}
+
+void set_Block_label(ir_node *block, ir_label_t label) {
+	assert(is_Block(block));
+	block->attr.block.has_label = 1;
+	block->attr.block.label = label;
+}
+
 int
 get_End_n_keepalives(ir_node *end) {
 	assert(end->op == op_End);
@@ -1063,8 +1101,16 @@ set_Const_tarval(ir_node *node, tarval *con) {
 	node->attr.con.tv = con;
 }
 
-cnst_classify_t (classify_Const)(ir_node *node) {
-	return _classify_Const(node);
+int (is_Const_null)(const ir_node *node) {
+	return _is_Const_null(node);
+}
+
+int (is_Const_one)(const ir_node *node) {
+	return _is_Const_one(node);
+}
+
+int (is_Const_all_one)(const ir_node *node) {
+	return _is_Const_all_one(node);
 }
 
 
@@ -1074,6 +1120,7 @@ cnst_classify_t (classify_Const)(ir_node *node) {
 ir_type *
 get_Const_type(ir_node *node) {
 	assert(node->op == op_Const);
+	node->attr.con.tp = skip_tid(node->attr.con.tp);
 	return node->attr.con.tp;
 }
 
@@ -1160,6 +1207,16 @@ set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
 	node->attr.symc.sym = sym;
 }
 
+ir_label_t get_SymConst_label(const ir_node *node) {
+	assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
+	return node->attr.symc.sym.label;
+}
+
+void set_SymConst_label(ir_node *node, ir_label_t label) {
+	assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
+	node->attr.symc.sym.label = label;
+}
+
 ir_type *
 get_SymConst_value_type(ir_node *node) {
 	assert(node->op == op_SymConst);
@@ -1429,6 +1486,7 @@ BINOP(Add)
 BINOP(Sub)
 UNOP(Minus)
 BINOP(Mul)
+BINOP(Mulh)
 DIVOP(Quot)
 DIVOP(DivMod)
 DIVOP(Div)
@@ -1446,7 +1504,7 @@ BINOP(Cmp)
 UNOP(Conv)
 UNOP(Cast)
 
-int get_Conv_strict(ir_node *node) {
+int get_Conv_strict(const ir_node *node) {
 	assert(node->op == op_Conv);
 	return node->attr.conv.strict;
 }
@@ -1459,6 +1517,7 @@ void set_Conv_strict(ir_node *node, int strict_flag) {
 ir_type *
 get_Cast_type(ir_node *node) {
 	assert(node->op == op_Cast);
+	node->attr.cast.totype = skip_tid(node->attr.cast.totype);
 	return node->attr.cast.totype;
 }
 
@@ -1476,9 +1535,8 @@ set_Cast_type(ir_node *node, ir_type *to_tp) {
 int is_Cast_upcast(ir_node *node) {
 	ir_type *totype   = get_Cast_type(node);
 	ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
-	ir_graph *myirg = get_irn_irg(node);
 
-	assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
+	assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
 	assert(fromtype);
 
 	while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
@@ -1565,19 +1623,9 @@ set_binop_right(ir_node *node, ir_node *right) {
 	set_irn_n(node, node->op->op_index + 1, right);
 }
 
-int is_Phi(const ir_node *n) {
-	ir_op *op;
-
-	assert(n);
-	op = get_irn_op(n);
-
-	if (op == op_Filter) return get_interprocedural_view();
-
-	if (op == op_Phi)
-		return ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
-		        (get_irn_arity(n) > 0));
-
-	return 0;
+int
+(is_Phi)(const ir_node *n) {
+	return _is_Phi(n);
 }
 
 int is_Phi0(const ir_node *n) {
@@ -1691,6 +1739,18 @@ set_Load_volatility(ir_node *node, ir_volatility volatility) {
 	node->attr.load.volatility = volatility;
 }
 
+ir_align
+get_Load_align(ir_node *node) {
+	assert(node->op == op_Load);
+	return node->attr.load.aligned;
+}
+
+void
+set_Load_align(ir_node *node, ir_align align) {
+	assert(node->op == op_Load);
+	node->attr.load.aligned = align;
+}
+
 
 ir_node *
 get_Store_mem(ir_node *node) {
@@ -1740,6 +1800,18 @@ set_Store_volatility(ir_node *node, ir_volatility volatility) {
 	node->attr.store.volatility = volatility;
 }
 
+ir_align
+get_Store_align(ir_node *node) {
+	assert(node->op == op_Store);
+	return node->attr.store.aligned;
+}
+
+void
+set_Store_align(ir_node *node, ir_align align) {
+	assert(node->op == op_Store);
+	node->attr.store.aligned = align;
+}
+
 
 ir_node *
 get_Alloc_mem(ir_node *node) {
@@ -2133,30 +2205,26 @@ void set_Mux_true(ir_node *node, ir_node *ir_true) {
 
 /* Psi support */
 ir_node *get_Psi_cond(ir_node *node, int pos) {
-	int num_conds = get_Psi_n_conds(node);
 	assert(node->op == op_Psi);
-	assert(pos < num_conds);
+	assert(pos < get_Psi_n_conds(node));
 	return get_irn_n(node, 2 * pos);
 }
 
 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
-	int num_conds = get_Psi_n_conds(node);
 	assert(node->op == op_Psi);
-	assert(pos < num_conds);
+	assert(pos < get_Psi_n_conds(node));
 	set_irn_n(node, 2 * pos, cond);
 }
 
 ir_node *get_Psi_val(ir_node *node, int pos) {
-	int num_vals = get_Psi_n_conds(node);
 	assert(node->op == op_Psi);
-	assert(pos < num_vals);
+	assert(pos < get_Psi_n_conds(node));
 	return get_irn_n(node, 2 * pos + 1);
 }
 
 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
-	int num_vals = get_Psi_n_conds(node);
 	assert(node->op == op_Psi);
-	assert(pos < num_vals);
+	assert(pos < get_Psi_n_conds(node));
 	set_irn_n(node, 2 * pos + 1, val);
 }
 
@@ -2388,9 +2456,9 @@ get_irn_irg(const ir_node *node) {
 	 * irg.
 	 */
 	if (! is_Block(node))
-		node = get_nodes_block(node);
+		node = get_irn_n(node, -1);
 	if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
-		node = get_nodes_block(node);
+		node = get_irn_n(node, -1);
 	assert(get_irn_op(node) == op_Block);
 	return node->attr.block.irg;
 }
@@ -2589,6 +2657,26 @@ int
 	return _is_Sub(node);
 }
 
+int
+(is_Shl)(const ir_node *node) {
+	return _is_Shl(node);
+}
+
+int
+(is_Shr)(const ir_node *node) {
+	return _is_Shr(node);
+}
+
+int
+(is_Shrs)(const ir_node *node) {
+	return _is_Shrs(node);
+}
+
+int
+(is_Rot)(const ir_node *node) {
+	return _is_Rot(node);
+}
+
 int
 (is_Not)(const ir_node *node) {
 	return _is_Not(node);
@@ -2624,6 +2712,16 @@ int
 	return _is_Conv(node);
 }
 
+int
+(is_strictConv)(const ir_node *node) {
+	return _is_strictConv(node);
+}
+
+int
+(is_Cast)(const ir_node *node) {
+	return _is_Cast(node);
+}
+
 int
 (is_no_Block)(const ir_node *node) {
 	return _is_no_Block(node);
@@ -2742,7 +2840,7 @@ int
 }
 
 int
-is_Proj(const ir_node *node) {
+(is_Proj)(const ir_node *node) {
 	assert(node);
 	return node->op == op_Proj ||
 	       (!get_interprocedural_view() && node->op == op_Filter);
@@ -2781,7 +2879,8 @@ ir_node *get_fragile_op_mem(ir_node *node) {
 	case iro_Store :
 	case iro_Alloc :
 	case iro_Bound :
-		return get_irn_n(node, 0);
+	case iro_CopyB :
+		return get_irn_n(node, pn_Generic_M_regular);
 	case iro_Bad   :
 	case iro_Unknown:
 		return node;
@@ -2985,7 +3084,7 @@ void dump_irn(ir_node *n) {
 	int i, arity = get_irn_arity(n);
 	printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
 	if (!is_Block(n)) {
-		ir_node *pred = get_nodes_block(n);
+		ir_node *pred = get_irn_n(n, -1);
 		printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
 			get_irn_node_nr(pred), (void *)pred);
 	}
@@ -2998,5 +3097,5 @@ void dump_irn(ir_node *n) {
 }
 
 #else  /* DEBUG_libfirm */
-void dump_irn(ir_node *n) {}
+void dump_irn(ir_node *n) { (void) n; }
 #endif /* DEBUG_libfirm */