/*
- * 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.
*
res->attr.code_attr.label = (ir_label_t) -1;
}
- /* Remember entity in it's owner. */
+ /* Remember entity in its owner. */
if (owner != NULL)
add_compound_member(owner, res);
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)