/*
- * 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.
*
/* 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;
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();
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);
}
/**
#ifdef DEBUG_libfirm
newe->nr = get_irp_new_node_nr();
#endif
+ hook_new_entity(newe);
return newe;
}
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);
* 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:
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);
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);
}
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);
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;
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++)
}
-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;
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)
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));
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)
projects / libfirm / blobdiff