X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Farm%2Farm_new_nodes.c;h=4f6ca20a24d218bb78585394b0a6532b09f198e2;hb=09cc69761cce64b2f7e2b346f0cdaf269ec00407;hp=bf8d987cfb60adcc51d24a8e816035ec6335a3c4;hpb=9d3c8631459f431c313160dab5778e8a7b88dd92;p=libfirm

diff --git a/ir/be/arm/arm_new_nodes.c b/ir/be/arm/arm_new_nodes.c
index bf8d987cf..4f6ca20a2 100644
--- a/ir/be/arm/arm_new_nodes.c
+++ b/ir/be/arm/arm_new_nodes.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -214,13 +214,13 @@ static void arm_dump_node(FILE *F, ir_node *n, dump_reason_t reason)
 arm_attr_t *get_arm_attr(ir_node *node)
 {
 	assert(is_arm_irn(node) && "need arm node to get attributes");
-	return get_irn_generic_attr(node);
+	return (arm_attr_t*)get_irn_generic_attr(node);
 }
 
 const arm_attr_t *get_arm_attr_const(const ir_node *node)
 {
 	assert(is_arm_irn(node) && "need arm node to get attributes");
-	return get_irn_generic_attr_const(node);
+	return (const arm_attr_t*)get_irn_generic_attr_const(node);
 }
 
 static bool has_symconst_attr(const ir_node *node)
@@ -231,61 +231,73 @@ static bool has_symconst_attr(const ir_node *node)
 arm_SymConst_attr_t *get_arm_SymConst_attr(ir_node *node)
 {
 	assert(has_symconst_attr(node));
-	return get_irn_generic_attr(node);
+	return (arm_SymConst_attr_t*)get_irn_generic_attr(node);
 }
 
 const arm_SymConst_attr_t *get_arm_SymConst_attr_const(const ir_node *node)
 {
 	assert(has_symconst_attr(node));
-	return get_irn_generic_attr_const(node);
+	return (const arm_SymConst_attr_t*)get_irn_generic_attr_const(node);
 }
 
 static const arm_fConst_attr_t *get_arm_fConst_attr_const(const ir_node *node)
 {
 	assert(is_arm_fConst(node));
-	return get_irn_generic_attr_const(node);
+	return (const arm_fConst_attr_t*)get_irn_generic_attr_const(node);
 }
 
 static arm_fConst_attr_t *get_arm_fConst_attr(ir_node *node)
 {
 	assert(is_arm_fConst(node));
-	return get_irn_generic_attr(node);
+	return (arm_fConst_attr_t*)get_irn_generic_attr(node);
 }
 
 arm_farith_attr_t *get_arm_farith_attr(ir_node *node)
 {
 	assert(has_farith_attr(node));
-	return get_irn_generic_attr(node);
+	return (arm_farith_attr_t*)get_irn_generic_attr(node);
 }
 
 const arm_farith_attr_t *get_arm_farith_attr_const(const ir_node *node)
 {
 	assert(has_farith_attr(node));
-	return get_irn_generic_attr_const(node);
+	return (const arm_farith_attr_t*)get_irn_generic_attr_const(node);
 }
 
 arm_CondJmp_attr_t *get_arm_CondJmp_attr(ir_node *node)
 {
 	assert(is_arm_B(node));
-	return get_irn_generic_attr(node);
+	return (arm_CondJmp_attr_t*)get_irn_generic_attr(node);
 }
 
 const arm_CondJmp_attr_t *get_arm_CondJmp_attr_const(const ir_node *node)
 {
 	assert(is_arm_B(node));
-	return get_irn_generic_attr_const(node);
+	return (const arm_CondJmp_attr_t*)get_irn_generic_attr_const(node);
 }
 
 arm_SwitchJmp_attr_t *get_arm_SwitchJmp_attr(ir_node *node)
 {
 	assert(is_arm_SwitchJmp(node));
-	return get_irn_generic_attr(node);
+	return (arm_SwitchJmp_attr_t*)get_irn_generic_attr(node);
 }
 
 const arm_SwitchJmp_attr_t *get_arm_SwitchJmp_attr_const(const ir_node *node)
 {
 	assert(is_arm_SwitchJmp(node));
-	return get_irn_generic_attr_const(node);
+	return (const arm_SwitchJmp_attr_t*)get_irn_generic_attr_const(node);
+}
+
+arm_CopyB_attr_t *get_arm_CopyB_attr(ir_node *node)
+{
+	assert(is_arm_CopyB(node));
+	return (arm_CopyB_attr_t*)get_irn_generic_attr(node);
+}
+
+const arm_CopyB_attr_t *get_arm_CopyB_attr_const(const ir_node *node)
+{
+	assert(is_arm_CopyB(node));
+	return (const arm_CopyB_attr_t*)get_irn_generic_attr_const(node);
 }
 
 ir_tarval *get_fConst_value(const ir_node *node)
@@ -300,16 +312,16 @@ void set_fConst_value(ir_node *node, ir_tarval *tv)
 	attr->tv = tv;
 }
 
-pn_Cmp get_arm_CondJmp_pnc(const ir_node *node)
+ir_relation get_arm_CondJmp_relation(const ir_node *node)
 {
 	const arm_CondJmp_attr_t *attr = get_arm_CondJmp_attr_const(node);
-	return attr->pnc;
+	return attr->relation;
 }
 
-void set_arm_CondJmp_pnc(ir_node *node, pn_Cmp pnc)
+void set_arm_CondJmp_relation(ir_node *node, ir_relation relation)
 {
 	arm_CondJmp_attr_t *attr = get_arm_CondJmp_attr(node);
-	attr->pnc = pnc;
+	attr->relation = relation;
 }
 
 int get_arm_SwitchJmp_n_projs(const ir_node *node)
@@ -337,7 +349,7 @@ void set_arm_SwitchJmp_default_proj_num(ir_node *node, long default_proj_num)
 }
 
 /* Set the ARM machine node attributes to default values. */
-static void init_arm_attributes(ir_node *node, int flags,
+static void init_arm_attributes(ir_node *node, arch_irn_flags_t flags,
                          const arch_register_req_t ** in_reqs,
                          const be_execution_unit_t ***execution_units,
 						 int n_res)
@@ -362,7 +374,7 @@ static void init_arm_load_store_attributes(ir_node *res, ir_mode *ls_mode,
                                            int entity_sign, long offset,
                                            bool is_frame_entity)
 {
-	arm_load_store_attr_t *attr = get_irn_generic_attr(res);
+	arm_load_store_attr_t *attr = get_arm_load_store_attr(res);
 	attr->load_store_mode    = ls_mode;
 	attr->entity             = entity;
 	attr->entity_sign        = entity_sign;
@@ -375,7 +387,7 @@ static void init_arm_shifter_operand(ir_node *res, unsigned immediate_value,
                                      arm_shift_modifier_t shift_modifier,
                                      unsigned shift_immediate)
 {
-	arm_shifter_operand_t *attr = get_irn_generic_attr(res);
+	arm_shifter_operand_t *attr = get_arm_shifter_operand_attr(res);
 	attr->immediate_value = immediate_value;
 	attr->shift_modifier  = shift_modifier;
 	attr->shift_immediate = shift_immediate;
@@ -383,7 +395,7 @@ static void init_arm_shifter_operand(ir_node *res, unsigned immediate_value,
 
 static void init_arm_cmp_attr(ir_node *res, bool ins_permuted, bool is_unsigned)
 {
-	arm_cmp_attr_t *attr = get_irn_generic_attr(res);
+	arm_cmp_attr_t *attr = get_arm_cmp_attr(res);
 	attr->ins_permuted = ins_permuted;
 	attr->is_unsigned  = is_unsigned;
 }
@@ -391,31 +403,31 @@ static void init_arm_cmp_attr(ir_node *res, bool ins_permuted, bool is_unsigned)
 static void init_arm_SymConst_attributes(ir_node *res, ir_entity *entity,
                                          int symconst_offset)
 {
-	arm_SymConst_attr_t *attr = get_irn_generic_attr(res);
+	arm_SymConst_attr_t *attr = get_arm_SymConst_attr(res);
 	attr->entity    = entity;
 	attr->fp_offset = symconst_offset;
 }
 
 static void init_arm_farith_attributes(ir_node *res, ir_mode *mode)
 {
-	arm_farith_attr_t *attr = get_irn_generic_attr(res);
+	arm_farith_attr_t *attr = get_arm_farith_attr(res);
 	attr->mode = mode;
 }
 
 static void init_arm_CopyB_attributes(ir_node *res, unsigned size)
 {
-	arm_CopyB_attr_t *attr = get_irn_generic_attr(res);
+	arm_CopyB_attr_t *attr = get_arm_CopyB_attr(res);
 	attr->size = size;
 }
 
-static int cmp_attr_arm(ir_node *a, ir_node *b)
+static int cmp_attr_arm(const ir_node *a, const ir_node *b)
 {
 	(void) a;
 	(void) b;
 	return 0;
 }
 
-static int cmp_attr_arm_SymConst(ir_node *a, ir_node *b)
+static int cmp_attr_arm_SymConst(const ir_node *a, const ir_node *b)
 {
 	const arm_SymConst_attr_t *attr_a;
 	const arm_SymConst_attr_t *attr_b;
@@ -423,13 +435,13 @@ static int cmp_attr_arm_SymConst(ir_node *a, ir_node *b)
 	if (cmp_attr_arm(a, b))
 		return 1;
 
-	attr_a = get_irn_generic_attr_const(a);
-	attr_b = get_irn_generic_attr_const(b);
+	attr_a = get_arm_SymConst_attr_const(a);
+	attr_b = get_arm_SymConst_attr_const(b);
 	return attr_a->entity != attr_b->entity
 		|| attr_a->fp_offset != attr_b->fp_offset;
 }
 
-static int cmp_attr_arm_CopyB(ir_node *a, ir_node *b)
+static int cmp_attr_arm_CopyB(const ir_node *a, const ir_node *b)
 {
 	const arm_CopyB_attr_t *attr_a;
 	const arm_CopyB_attr_t *attr_b;
@@ -437,12 +449,12 @@ static int cmp_attr_arm_CopyB(ir_node *a, ir_node *b)
 	if (cmp_attr_arm(a, b))
 		return 1;
 
-	attr_a = get_irn_generic_attr_const(a);
-	attr_b = get_irn_generic_attr_const(b);
+	attr_a = get_arm_CopyB_attr_const(a);
+	attr_b = get_arm_CopyB_attr_const(b);
 	return attr_a->size != attr_b->size;
 }
 
-static int cmp_attr_arm_CondJmp(ir_node *a, ir_node *b)
+static int cmp_attr_arm_CondJmp(const ir_node *a, const ir_node *b)
 {
 	(void) a;
 	(void) b;
@@ -450,7 +462,7 @@ static int cmp_attr_arm_CondJmp(ir_node *a, ir_node *b)
 	return 1;
 }
 
-static int cmp_attr_arm_SwitchJmp(ir_node *a, ir_node *b)
+static int cmp_attr_arm_SwitchJmp(const ir_node *a, const ir_node *b)
 {
 	(void) a;
 	(void) b;
@@ -458,7 +470,7 @@ static int cmp_attr_arm_SwitchJmp(ir_node *a, ir_node *b)
 	return 1;
 }
 
-static int cmp_attr_arm_fConst(ir_node *a, ir_node *b)
+static int cmp_attr_arm_fConst(const ir_node *a, const ir_node *b)
 {
 	const arm_fConst_attr_t *attr_a;
 	const arm_fConst_attr_t *attr_b;
@@ -504,7 +516,7 @@ const arm_cmp_attr_t *get_arm_cmp_attr_const(const ir_node *node)
 	return (const arm_cmp_attr_t*) get_irn_generic_attr_const(node);
 }
 
-static int cmp_attr_arm_load_store(ir_node *a, ir_node *b)
+static int cmp_attr_arm_load_store(const ir_node *a, const ir_node *b)
 {
 	const arm_load_store_attr_t *attr_a;
 	const arm_load_store_attr_t *attr_b;
@@ -512,8 +524,8 @@ static int cmp_attr_arm_load_store(ir_node *a, ir_node *b)
 	if (cmp_attr_arm(a, b))
 		return 1;
 
-	attr_a = get_arm_load_store_attr(a);
-	attr_b = get_arm_load_store_attr(b);
+	attr_a = get_arm_load_store_attr_const(a);
+	attr_b = get_arm_load_store_attr_const(b);
 	if (attr_a->entity != attr_b->entity
 			|| attr_a->entity_sign != attr_b->entity_sign
 			|| attr_a->offset != attr_b->offset)
@@ -522,7 +534,7 @@ static int cmp_attr_arm_load_store(ir_node *a, ir_node *b)
 	return 0;
 }
 
-static int cmp_attr_arm_shifter_operand(ir_node *a, ir_node *b)
+static int cmp_attr_arm_shifter_operand(const ir_node *a, const ir_node *b)
 {
 	const arm_shifter_operand_t *attr_a;
 	const arm_shifter_operand_t *attr_b;
@@ -530,8 +542,8 @@ static int cmp_attr_arm_shifter_operand(ir_node *a, ir_node *b)
 	if (cmp_attr_arm(a, b))
 		return 1;
 
-	attr_a = get_arm_shifter_operand_attr(a);
-	attr_b = get_arm_shifter_operand_attr(b);
+	attr_a = get_arm_shifter_operand_attr_const(a);
+	attr_b = get_arm_shifter_operand_attr_const(b);
 	if (attr_a->shift_modifier != attr_b->shift_modifier
 			|| attr_a->immediate_value != attr_b->immediate_value
 			|| attr_a->shift_immediate != attr_b->shift_immediate)
@@ -540,7 +552,7 @@ static int cmp_attr_arm_shifter_operand(ir_node *a, ir_node *b)
 	return 0;
 }
 
-static int cmp_attr_arm_cmp(ir_node *a, ir_node *b)
+static int cmp_attr_arm_cmp(const ir_node *a, const ir_node *b)
 {
 	const arm_cmp_attr_t *attr_a;
 	const arm_cmp_attr_t *attr_b;
@@ -548,15 +560,15 @@ static int cmp_attr_arm_cmp(ir_node *a, ir_node *b)
 	if (cmp_attr_arm(a, b))
 		return 1;
 
-	attr_a = get_irn_generic_attr_const(a);
-	attr_b = get_irn_generic_attr_const(b);
+	attr_a = get_arm_cmp_attr_const(a);
+	attr_b = get_arm_cmp_attr_const(b);
 	if (attr_a->ins_permuted != attr_b->ins_permuted
 			|| attr_a->is_unsigned != attr_b->is_unsigned)
 		return 1;
 	return 0;
 }
 
-static int cmp_attr_arm_farith(ir_node *a, ir_node *b)
+static int cmp_attr_arm_farith(const ir_node *a, const ir_node *b)
 {
 	const arm_farith_attr_t *attr_a;
 	const arm_farith_attr_t *attr_b;