X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=2666aa939482f5be6cc616e1780b017288488c59;hb=94bae803683a67bd6fdf43d7e30040a8f8c730b3;hp=8f0d2abc6151f7aebce57b0ba20a68bf38cf0042;hpb=41eca21e7add2e4f30f14c46600a23839852b3fc;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 8f0d2abc6..2666aa939 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -525,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) {
@@ -636,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]);
@@ -658,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);
 }
@@ -1289,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 */
@@ -1300,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;
 }
 
 
@@ -1363,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 *
@@ -1424,14 +1430,14 @@ 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. */
@@ -1441,7 +1447,7 @@ const char *get_builtin_kind_name(ir_builtin_kind kind) {
 		X(ir_bk_trap);
 		X(ir_bk_debugbreak);
 		X(ir_bk_return_address);
-		X(ir_bk_frame_addess);
+		X(ir_bk_frame_address);
 		X(ir_bk_prefetch);
 		X(ir_bk_ffs);
 		X(ir_bk_clz);
@@ -1571,16 +1577,17 @@ 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;                     \
 }
 
 
 BINOP(Add)
+BINOP(Borrow)
 BINOP(Carry)
 BINOP(Sub)
 UNOP(Minus)
@@ -1603,11 +1610,16 @@ 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;
 }
 
+void set_Div_no_remainder(ir_node *node, int no_remainder) {
+	assert(is_Div(node));
+	node->attr.divmod.no_remainder = no_remainder;
+}
+
 int get_Conv_strict(const ir_node *node) {
 	assert(is_Conv(node));
 	return node->attr.conv.strict;
@@ -1621,14 +1633,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;
 }
 
 
@@ -1727,11 +1739,6 @@ 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) {
-	return _is_Phi(n);
-}
-
 int is_Phi0(const ir_node *n) {
 	assert(n);
 
@@ -1830,13 +1837,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
@@ -2346,12 +2353,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;
 }
 
 
@@ -2678,310 +2685,22 @@ void skip_Id_and_store(ir_node **node) {
 	*node = skip_Id(n);
 }
 
-int
-(is_Bad)(const ir_node *node) {
-	return _is_Bad(node);
-}
-
-int
-(is_NoMem)(const ir_node *node) {
-	return _is_NoMem(node);
-}
-
-int
-(is_Minus)(const ir_node *node) {
-	return _is_Minus(node);
-}
-
-int
-(is_Abs)(const ir_node *node) {
-	return _is_Abs(node);
-}
-
-int
-(is_Mod)(const ir_node *node) {
-	return _is_Mod(node);
-}
-
-int
-(is_Div)(const ir_node *node) {
-	return _is_Div(node);
-}
-
-int
-(is_DivMod)(const ir_node *node) {
-	return _is_DivMod(node);
-}
-
-int
-(is_Quot)(const ir_node *node) {
-	return _is_Quot(node);
-}
-
-int
-(is_Add)(const ir_node *node) {
-	return _is_Add(node);
-}
-
-int
-(is_Carry)(const ir_node *node) {
-	return _is_Carry(node);
-}
-
-int
-(is_And)(const ir_node *node) {
-	return _is_And(node);
-}
-
-int
-(is_Or)(const ir_node *node) {
-	return _is_Or(node);
-}
-
-int
-(is_Eor)(const ir_node *node) {
-	return _is_Eor(node);
-}
-
-int
-(is_Sub)(const ir_node *node) {
-	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_Rotl)(const ir_node *node) {
-	return _is_Rotl(node);
-}
-
-int
-(is_Not)(const ir_node *node) {
-	return _is_Not(node);
-}
-
-int
-(is_Id)(const ir_node *node) {
-	return _is_Id(node);
-}
-
-int
-(is_Tuple)(const ir_node *node) {
-	return _is_Tuple(node);
-}
-
-int
-(is_Bound)(const ir_node *node) {
-	return _is_Bound(node);
-}
-
-int
-(is_Start)(const ir_node *node) {
-  return _is_Start(node);
-}
-
-int
-(is_End)(const ir_node *node) {
-	return _is_End(node);
-}
-
-int
-(is_Const)(const ir_node *node) {
-	return _is_Const(node);
-}
-
-int
-(is_Conv)(const ir_node *node) {
-	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);
 }
 
-int
-(is_Block)(const ir_node *node) {
-	return _is_Block(node);
-}
-
-/* returns true if node is an Unknown node. */
-int
-(is_Unknown)(const ir_node *node) {
-	return _is_Unknown(node);
-}
-
-/* returns true if node is a Return node. */
-int
-(is_Return)(const ir_node *node) {
-	return _is_Return(node);
-}
-
-/* returns true if node is a Call node. */
-int
-(is_Call)(const ir_node *node) {
-	return _is_Call(node);
-}
-
-/* returns true if node is a Builtin node. */
-int
-(is_Builtin)(const ir_node *node) {
-	return _is_Builtin(node);
-}
-
-/* returns true if node is a CallBegin node. */
-int
-(is_CallBegin)(const ir_node *node) {
-	return _is_CallBegin(node);
-}
-
-/* returns true if node is a Sel node. */
-int
-(is_Sel)(const ir_node *node) {
-	return _is_Sel(node);
-}
-
-/* returns true if node is a Mux node. */
-int
-(is_Mux)(const ir_node *node) {
-	return _is_Mux(node);
-}
-
-/* returns true if node is a Load node. */
-int
-(is_Load)(const ir_node *node) {
-	return _is_Load(node);
-}
-
-/* returns true if node is a Load node. */
-int
-(is_Store)(const ir_node *node) {
-	return _is_Store(node);
-}
-
-/* returns true if node is a Sync node. */
-int
-(is_Sync)(const ir_node *node) {
-	return _is_Sync(node);
-}
-
-/* Returns true if node is a Confirm node. */
-int
-(is_Confirm)(const ir_node *node) {
-	return _is_Confirm(node);
-}
-
-/* Returns true if node is a Pin node. */
-int
-(is_Pin)(const ir_node *node) {
-	return _is_Pin(node);
-}
-
-/* Returns true if node is a SymConst node. */
-int
-(is_SymConst)(const ir_node *node) {
-	return _is_SymConst(node);
-}
-
 /* Returns true if node is a SymConst node with kind symconst_addr_ent. */
 int
 (is_SymConst_addr_ent)(const ir_node *node) {
 	return _is_SymConst_addr_ent(node);
 }
 
-/* Returns true if node is a Cond node. */
-int
-(is_Cond)(const ir_node *node) {
-	return _is_Cond(node);
-}
-
-int
-(is_CopyB)(const ir_node *node) {
-	return _is_CopyB(node);
-}
-
-/* returns true if node is a Cmp node. */
-int
-(is_Cmp)(const ir_node *node) {
-	return _is_Cmp(node);
-}
-
-/* returns true if node is an Alloc node. */
-int
-(is_Alloc)(const ir_node *node) {
-	return _is_Alloc(node);
-}
-
-/* returns true if node is a Free node. */
-int
-(is_Free)(const ir_node *node) {
-	return _is_Free(node);
-}
-
-/* returns true if a node is a Jmp node. */
-int
-(is_Jmp)(const ir_node *node) {
-	return _is_Jmp(node);
-}
-
-/* returns true if a node is a IJmp node. */
-int
-(is_IJmp)(const ir_node *node) {
-	return _is_IJmp(node);
-}
-
-/* returns true if a node is a Raise node. */
-int
-(is_Raise)(const ir_node *node) {
-	return _is_Raise(node);
-}
-
-/* returns true if a node is an ASM node. */
-int
-(is_ASM)(const ir_node *node) {
-	return _is_ASM(node);
-}
-
-/* returns true if a node is an Dummy node. */
-int
-(is_Dummy)(const ir_node *node) {
-	return _is_Dummy(node);
-}
-
-int
-(is_Proj)(const ir_node *node) {
-	return _is_Proj(node);
-}
-
-/* Returns true if node is a Filter node. */
-int
-(is_Filter)(const ir_node *node) {
-	return _is_Filter(node);
-}
-
 /* Returns true if the operation manipulates control flow. */
 int is_cfop(const ir_node *node) {
 	return is_op_cfopcode(get_irn_op(node));
@@ -3214,30 +2933,6 @@ dbg_info *(get_irn_dbg_info)(const ir_node *n) {
 	return _get_irn_dbg_info(n);
 }
 
-#if 0 /* allow the global pointer */
-
-/* checks whether a node represents a global address */
-int is_Global(const ir_node *node) {
-	ir_node *ptr;
-
-	if (is_SymConst_addr_ent(node))
-		return 1;
-	if (! is_Sel(node))
-		return 0;
-
-	ptr = get_Sel_ptr(node);
-	return is_globals_pointer(ptr) != NULL;
-}
-
-/* returns the entity of a global address */
-ir_entity *get_Global_entity(const ir_node *node) {
-	if (is_SymConst(node))
-		return get_SymConst_entity(node);
-	else
-		return get_Sel_entity(node);
-}
-#else
-
 /* checks whether a node represents a global address */
 int is_Global(const ir_node *node) {
 	return is_SymConst_addr_ent(node);
@@ -3247,7 +2942,6 @@ int is_Global(const ir_node *node) {
 ir_entity *get_Global_entity(const ir_node *node) {
 	return get_SymConst_entity(node);
 }
-#endif
 
 /*
  * Calculate a hash value of a node.
@@ -3271,3 +2965,6 @@ unsigned firm_default_hash(const ir_node *node) {
 
 	return h;
 }  /* firm_default_hash */
+
+/* include generated code */
+#include "gen_irnode.c.inl"