X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=27612ca95f49b611503b76105f083ae3e6c79b95;hb=4524bf07ed17f358412754a50a76e7db852160b3;hp=dbef0ed08ae55c117d0fd5611f80c822d8160719;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index dbef0ed08..27612ca95 100644
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.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.
  *
@@ -60,13 +60,11 @@ ir_entity *get_unknown_entity(void) { return unknown_entity; }
 /* ENTITY                                                          */
 /*-----------------------------------------------------------------*/
 
-ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type,
-                        dbg_info *db)
+static ir_entity *intern_new_entity(ir_type *owner, ident *name, ir_type *type,
+                                    dbg_info *dbgi)
 {
 	ir_entity *res;
 
-	assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
-
 	res = XMALLOCZ(ir_entity);
 
 	res->kind    = k_entity;
@@ -85,6 +83,24 @@ ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type,
 	res->alignment            = 0;
 	res->link                 = NULL;
 	res->repr_class           = NULL;
+#ifdef DEBUG_libfirm
+	res->nr = get_irp_new_node_nr();
+#endif
+
+	/* Remember entity in its owner. */
+	if (owner != NULL)
+		add_compound_member(owner, res);
+
+	res->visit = 0;
+	set_entity_dbg_info(res, dbgi);
+
+	return res;
+}
+
+ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type,
+                        dbg_info *db)
+{
+	ir_entity *res = intern_new_entity(owner, name, type, db);
 
 	if (is_Method_type(type)) {
 		ir_graph *irg = get_const_code_irg();
@@ -105,25 +121,36 @@ ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type,
 		res->attr.code_attr.label = (ir_label_t) -1;
 	}
 
-	/* Remember entity in it's owner. */
-	if (owner != NULL)
-		add_compound_member(owner, res);
+	hook_new_entity(res);
+	return res;
+}
 
-#ifdef DEBUG_libfirm
-	res->nr = get_irp_new_node_nr();
-#endif
+ir_entity *new_entity(ir_type *owner, ident *name, ir_type *type)
+{
+	return new_d_entity(owner, name, type, NULL);
+}
 
-	res->visit = 0;
-	set_entity_dbg_info(res, db);
+static ident *make_parameter_entity_name(size_t pos)
+{
+	char buf[64];
+	snprintf(buf, sizeof(buf), "parameter.%lu", (unsigned long) pos);
+	return new_id_from_str(buf);
+}
 
+ir_entity *new_d_parameter_entity(ir_type *owner, size_t pos, ir_type *type,
+                                  dbg_info *dbgi)
+{
+	ident     *name            = make_parameter_entity_name(pos);
+	ir_entity *res             = intern_new_entity(owner, name, type, dbgi);
+	res->is_parameter          = true;
+	res->attr.parameter.number = pos;
 	hook_new_entity(res);
-
 	return res;
 }
 
-ir_entity *new_entity(ir_type *owner, ident *name, ir_type *type)
+ir_entity *new_parameter_entity(ir_type *owner, size_t pos, ir_type *type)
 {
-	return new_d_entity(owner, name, type, NULL);
+	return new_d_parameter_entity(owner, pos, type, NULL);
 }
 
 /**
@@ -193,6 +220,7 @@ static ir_entity *deep_entity_copy(ir_entity *old)
 #ifdef DEBUG_libfirm
 	newe->nr = get_irp_new_node_nr();
 #endif
+	hook_new_entity(newe);
 	return newe;
 }
 
@@ -301,6 +329,11 @@ const char *(get_entity_ld_name)(const ir_entity *ent)
 	return _get_entity_ld_name(ent);
 }
 
+int entity_has_ld_ident(const ir_entity *entity)
+{
+	return entity->ld_name != NULL;
+}
+
 ir_type *(get_entity_type)(const ir_entity *ent)
 {
 	return _get_entity_type(ent);
@@ -481,15 +514,12 @@ void set_atomic_ent_value(ir_entity *entity, ir_node *val)
  *  const_code_irg. */
 int is_irn_const_expression(ir_node *n)
 {
-	ir_mode *m;
-
 	/* we are in danger iff an exception will arise. TODO: be more precisely,
 	 * for instance Div. will NOT rise if divisor != 0
 	 */
 	if (is_binop(n) && !is_fragile_op(n))
 		return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
 
-	m = get_irn_mode(n);
 	switch (get_irn_opcode(n)) {
 	case iro_Const:
 	case iro_SymConst:
@@ -617,13 +647,14 @@ ir_initializer_t *create_initializer_tarval(ir_tarval *tv)
 	return initializer;
 }
 
-ir_initializer_t *create_initializer_compound(unsigned n_entries)
+ir_initializer_t *create_initializer_compound(size_t n_entries)
 {
 	struct obstack *obst = get_irg_obstack(get_const_code_irg());
 
 	size_t i;
 	size_t size  = sizeof(ir_initializer_compound_t)
-	             + (n_entries-1) * sizeof(ir_initializer_t*);
+	             + n_entries * sizeof(ir_initializer_t*)
+	             - sizeof(ir_initializer_t*);
 
 	ir_initializer_t *initializer
 		= (ir_initializer_t*)obstack_alloc(obst, size);
@@ -649,14 +680,14 @@ ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initializer)
 	return initializer->tarval.value;
 }
 
-unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer)
+size_t get_initializer_compound_n_entries(const ir_initializer_t *initializer)
 {
 	assert(initializer->kind == IR_INITIALIZER_COMPOUND);
 	return initializer->compound.n_initializers;
 }
 
 void set_initializer_compound_value(ir_initializer_t *initializer,
-                                    unsigned index, ir_initializer_t *value)
+                                    size_t index, ir_initializer_t *value)
 {
 	assert(initializer->kind == IR_INITIALIZER_COMPOUND);
 	assert(index < initializer->compound.n_initializers);
@@ -665,7 +696,7 @@ void set_initializer_compound_value(ir_initializer_t *initializer,
 }
 
 ir_initializer_t *get_initializer_compound_value(
-		const ir_initializer_t *initializer, unsigned index)
+		const ir_initializer_t *initializer, size_t index)
 {
 	assert(initializer->kind == IR_INITIALIZER_COMPOUND);
 	assert(index < initializer->compound.n_initializers);
@@ -748,31 +779,31 @@ void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
 	ARR_APP1(ir_entity *, overwritten->overwrittenby, ent);
 }
 
-int get_entity_n_overwrites(const ir_entity *ent)
+size_t get_entity_n_overwrites(const ir_entity *ent)
 {
 	if (ent->overwrites == NULL)
 		return 0;
 	return ARR_LEN(ent->overwrites);
 }
 
-int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten)
+size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten)
 {
-	int i, n;
-	n = get_entity_n_overwrites(ent);
+	size_t i;
+	size_t n = get_entity_n_overwrites(ent);
 	for (i = 0; i < n; ++i) {
 		if (get_entity_overwrites(ent, i) == overwritten)
 			return i;
 	}
-	return -1;
+	return (size_t)-1;
 }
 
-ir_entity *get_entity_overwrites(const ir_entity *ent, int pos)
+ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos)
 {
 	assert(pos < get_entity_n_overwrites(ent));
 	return ent->overwrites[pos];
 }
 
-void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten)
+void set_entity_overwrites(ir_entity *ent, size_t pos, ir_entity *overwritten)
 {
 	assert(pos < get_entity_n_overwrites(ent));
 	ent->overwrites[pos] = overwritten;
@@ -780,8 +811,8 @@ void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten)
 
 void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
 {
-	int i, n;
-	n = get_entity_n_overwrites(ent);
+	size_t i;
+	size_t n = get_entity_n_overwrites(ent);
 	for (i = 0; i < n; ++i) {
 		if (ent->overwrites[i] == overwritten) {
 			for (; i < n - 1; i++)
@@ -793,31 +824,32 @@ void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
 }
 
 
-int get_entity_n_overwrittenby(const ir_entity *ent)
+size_t get_entity_n_overwrittenby(const ir_entity *ent)
 {
 	if (ent->overwrittenby == NULL)
 		return 0;
 	return ARR_LEN(ent->overwrittenby);
 }
 
-int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites)
+size_t get_entity_overwrittenby_index(const ir_entity *ent,
+                                      ir_entity *overwrites)
 {
-	int i, n;
-	n = get_entity_n_overwrittenby(ent);
+	size_t i;
+	size_t n = get_entity_n_overwrittenby(ent);
 	for (i = 0; i < n; ++i) {
 		if (get_entity_overwrittenby(ent, i) == overwrites)
 			return i;
 	}
-	return -1;
+	return (size_t)-1;
 }
 
-ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos)
+ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos)
 {
 	assert(pos < get_entity_n_overwrittenby(ent));
 	return ent->overwrittenby[pos];
 }
 
-void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites)
+void set_entity_overwrittenby(ir_entity *ent, size_t pos, ir_entity *overwrites)
 {
 	assert(pos < get_entity_n_overwrittenby(ent));
 	ent->overwrittenby[pos] = overwrites;
@@ -825,9 +857,8 @@ void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites)
 
 void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites)
 {
-	int i, n;
-
-	n = get_entity_n_overwrittenby(ent);
+	size_t i;
+	size_t n = get_entity_n_overwrittenby(ent);
 	for (i = 0; i < n; ++i) {
 		if (ent->overwrittenby[i] == overwrites) {
 			for (; i < n - 1; ++i)
@@ -860,6 +891,22 @@ void set_entity_irg(ir_entity *ent, ir_graph *irg)
 	ent->attr.mtd_attr.irg = irg;
 }
 
+int (is_parameter_entity)(const ir_entity *entity)
+{
+	return _is_parameter_entity(entity);
+}
+
+size_t (get_entity_parameter_number)(const ir_entity *entity)
+{
+	return _get_entity_parameter_number(entity);
+}
+
+void set_entity_parameter_number(ir_entity *entity, size_t n)
+{
+	assert(is_parameter_entity(entity));
+	entity->attr.parameter.number = n;
+}
+
 unsigned get_entity_vtable_number(const ir_entity *ent)
 {
 	assert(is_method_entity((ir_entity *)ent));
@@ -890,7 +937,7 @@ int is_compound_entity(const ir_entity *ent)
 	ir_type     *t  = get_entity_type(ent);
 	const tp_op *op = get_type_tpop(t);
 	return (op == type_class || op == type_struct ||
-		op == type_array || op == type_union);
+	        op == type_array || op == type_union);
 }
 
 int is_method_entity(const ir_entity *ent)