X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=228b14830a6ee0712c2d5ef69c184ee5a03770fb;hb=69d11aa49aa17358468bbb2f5506ef5f009514e9;hp=02ec1d6b4b7e0e031e6f8af6a00f143f4ed868ae;hpb=ac49539a0d2e60bc02bbd848247355cd782b2c83;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 02ec1d6b4..228b14830 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -163,13 +163,10 @@ new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mod
 		memcpy(&res->in[1], in, sizeof(ir_node *) * arity);
 	}
 
-	res->in[0] = block;
+	res->in[0]   = block;
 	set_irn_dbg_info(res, db);
-	res->out = NULL;
-
-#ifdef DEBUG_libfirm
+	res->out     = NULL;
 	res->node_nr = get_irp_new_node_nr();
-#endif
 
 	for (i = 0; i < EDGE_KIND_LAST; ++i)
 		INIT_LIST_HEAD(&res->edge_info[i].outs_head);
@@ -497,11 +494,7 @@ void set_irn_pinned(ir_node *node, op_pin_state state) {
 /* Outputs a unique number for this node */
 long get_irn_node_nr(const ir_node *node) {
 	assert(node);
-#ifdef DEBUG_libfirm
 	return node->node_nr;
-#else
-	return (long)PTR_TO_INT(node);
-#endif
 }
 
 const_attr *get_irn_const_attr(ir_node *node) {
@@ -532,7 +525,7 @@ symconst_attr *get_irn_symconst_attr(ir_node *node) {
 
 ir_type *get_irn_call_attr(ir_node *node) {
 	assert(is_Call(node));
-	return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
+	return node->attr.call.type = skip_tid(node->attr.call.type);
 }
 
 sel_attr *get_irn_sel_attr(ir_node *node) {
@@ -643,10 +636,6 @@ ir_type *is_tls_pointer(const ir_node *n) {
 	return NULL;
 }
 
-/* Returns an array with the predecessors of the Block. Depending on
-   the implementation of the graph data structure this can be a copy of
-   the internal representation of predecessors as well as the internal
-   array itself. Therefore writing to this array might obstruct the ir. */
 ir_node **get_Block_cfgpred_arr(ir_node *node) {
 	assert(is_Block(node));
 	return (ir_node **)&(get_irn_in(node)[1]);
@@ -665,6 +654,16 @@ void set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
 	set_irn_n(node, pos, pred);
 }
 
+int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred) {
+	int i;
+
+	for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
+		if (get_Block_cfgpred_block(block, i) == pred)
+			return i;
+	}
+	return -1;
+}
+
 ir_node *(get_Block_cfgpred_block)(const ir_node *node, int pos) {
 	return _get_Block_cfgpred_block(node, pos);
 }
@@ -1006,6 +1005,18 @@ I don't want to choose 3) as 2a) seems to have advantages for
 dataflow analysis and 3) does not allow to convert the representation to
 2a).
 */
+
+const char *get_cond_kind_name(cond_kind kind)
+{
+#define X(a)    case a: return #a;
+	switch (kind) {
+		X(dense);
+		X(fragmentary);
+	}
+	return "<unknown>";
+#undef X
+}
+
 ir_node *
 get_Cond_selector(const ir_node *node) {
 	assert(is_Cond(node));
@@ -1031,11 +1042,16 @@ set_Cond_kind(ir_node *node, cond_kind kind) {
 }
 
 long
-get_Cond_defaultProj(const ir_node *node) {
+get_Cond_default_proj(const ir_node *node) {
 	assert(is_Cond(node));
 	return node->attr.cond.default_proj;
 }
 
+void set_Cond_default_proj(ir_node *node, long defproj) {
+	assert(is_Cond(node));
+	node->attr.cond.default_proj = defproj;
+}
+
 ir_node *
 get_Return_mem(const ir_node *node) {
 	assert(is_Return(node));
@@ -1279,7 +1295,7 @@ set_Sel_index(ir_node *node, int pos, ir_node *index) {
 ir_entity *
 get_Sel_entity(const ir_node *node) {
 	assert(is_Sel(node));
-	return node->attr.sel.ent;
+	return node->attr.sel.entity;
 }
 
 /* need a version without const to prevent warning */
@@ -1290,7 +1306,7 @@ static ir_entity *_get_Sel_entity(ir_node *node) {
 void
 set_Sel_entity(ir_node *node, ir_entity *ent) {
 	assert(is_Sel(node));
-	node->attr.sel.ent = ent;
+	node->attr.sel.entity = ent;
 }
 
 
@@ -1353,14 +1369,14 @@ set_Call_param(ir_node *node, int pos, ir_node *param) {
 ir_type *
 get_Call_type(ir_node *node) {
 	assert(is_Call(node));
-	return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
+	return node->attr.call.type = skip_tid(node->attr.call.type);
 }
 
 void
 set_Call_type(ir_node *node, ir_type *tp) {
 	assert(is_Call(node));
 	assert((get_unknown_type() == tp) || is_Method_type(tp));
-	node->attr.call.cld_tp = tp;
+	node->attr.call.type = tp;
 }
 
 ir_node *
@@ -1414,19 +1430,19 @@ set_Builtin_param(ir_node *node, int pos, ir_node *param) {
 ir_type *
 get_Builtin_type(ir_node *node) {
 	assert(is_Builtin(node));
-	return node->attr.builtin.builtin_tp = skip_tid(node->attr.builtin.builtin_tp);
+	return node->attr.builtin.type = skip_tid(node->attr.builtin.type);
 }
 
 void
 set_Builtin_type(ir_node *node, ir_type *tp) {
 	assert(is_Builtin(node));
 	assert((get_unknown_type() == tp) || is_Method_type(tp));
-	node->attr.builtin.builtin_tp = tp;
+	node->attr.builtin.type = tp;
 }
 
 /* Returns a human readable string for the ir_builtin_kind. */
 const char *get_builtin_kind_name(ir_builtin_kind kind) {
-#define X(a)    case a: return #a + 6;
+#define X(a)    case a: return #a;
 	switch (kind) {
 		X(ir_bk_trap);
 		X(ir_bk_debugbreak);
@@ -1561,12 +1577,12 @@ BINOP_MEM(OP)                                           \
                                                         \
 ir_mode *get_##OP##_resmode(const ir_node *node) {      \
   assert(is_##OP(node));                                \
-  return node->attr.divmod.res_mode;                    \
+  return node->attr.divmod.resmode;                     \
 }                                                       \
                                                         \
 void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \
   assert(is_##OP(node));                                \
-  node->attr.divmod.res_mode = mode;                    \
+  node->attr.divmod.resmode = mode;                     \
 }
 
 
@@ -1593,7 +1609,7 @@ BINOP(Cmp)
 UNOP(Conv)
 UNOP(Cast)
 
-int is_Div_remainderless(const ir_node *node) {
+int get_Div_no_remainder(const ir_node *node) {
 	assert(is_Div(node));
 	return node->attr.divmod.no_remainder;
 }
@@ -1611,14 +1627,14 @@ void set_Conv_strict(ir_node *node, int strict_flag) {
 ir_type *
 get_Cast_type(ir_node *node) {
 	assert(is_Cast(node));
-	node->attr.cast.totype = skip_tid(node->attr.cast.totype);
-	return node->attr.cast.totype;
+	node->attr.cast.type = skip_tid(node->attr.cast.type);
+	return node->attr.cast.type;
 }
 
 void
 set_Cast_type(ir_node *node, ir_type *to_tp) {
 	assert(is_Cast(node));
-	node->attr.cast.totype = to_tp;
+	node->attr.cast.type = to_tp;
 }
 
 
@@ -1820,13 +1836,13 @@ set_Load_ptr(ir_node *node, ir_node *ptr) {
 ir_mode *
 get_Load_mode(const ir_node *node) {
 	assert(is_Load(node));
-	return node->attr.load.load_mode;
+	return node->attr.load.mode;
 }
 
 void
 set_Load_mode(ir_node *node, ir_mode *mode) {
 	assert(is_Load(node));
-	node->attr.load.load_mode = mode;
+	node->attr.load.mode = mode;
 }
 
 ir_volatility
@@ -2336,12 +2352,12 @@ void set_CopyB_src(ir_node *node, ir_node *src) {
 
 ir_type *get_CopyB_type(ir_node *node) {
 	assert(is_CopyB(node));
-	return node->attr.copyb.data_type = skip_tid(node->attr.copyb.data_type);
+	return node->attr.copyb.type = skip_tid(node->attr.copyb.type);
 }
 
 void set_CopyB_type(ir_node *node, ir_type *data_type) {
 	assert(is_CopyB(node) && data_type);
-	node->attr.copyb.data_type = data_type;
+	node->attr.copyb.type = data_type;
 }
 
 
@@ -3089,12 +3105,14 @@ int (is_irn_machine_user)(const ir_node *node, unsigned n) {
 
 /* Gets the string representation of the jump prediction .*/
 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
+#define X(a)    case a: return #a;
 	switch (pred) {
-	default:
-	case COND_JMP_PRED_NONE:  return "no prediction";
-	case COND_JMP_PRED_TRUE:  return "true taken";
-	case COND_JMP_PRED_FALSE: return "false taken";
+		X(COND_JMP_PRED_NONE);
+		X(COND_JMP_PRED_TRUE);
+		X(COND_JMP_PRED_FALSE);
 	}
+	return "<unknown>";
+#undef X
 }
 
 /* Returns the conditional jump prediction of a Cond node. */