/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors: Martin Trapp, Christian Schaefer
-**
+* All rights reserved.
+*
+* Authors: Martin Trapp, Christian Schaefer
+*
*/
/* $Id$ */
# include "typegmod_t.h"
# include "array.h"
/* All this is needed to build the constant node for methods: */
-# include "irprog.h"
+# include "irprog_t.h"
# include "ircons.h"
+# include "tv_t.h"
/*******************************************************************/
/** general **/
/*******************************************************************/
-unsigned long entity_visited;
-
void
init_entity (void)
{
/** ENTITY **/
/*******************************************************************/
+/* redeclared to declare INLINE. */
+INLINE entity *get_entity_overwrites (entity *ent, int pos);
+INLINE entity *get_entity_overwrittenby (entity *ent, int pos);
+INLINE type *get_entity_owner (entity *ent);
+
INLINE void insert_entity_in_owner (entity *ent) {
type *owner = ent->owner;
switch (get_type_tpop_code(owner)) {
entity *res;
ir_graph *rem;
+ assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
+
res = (entity *) malloc (sizeof (entity));
res->kind = k_entity;
assert_legal_owner_of_ent(owner);
res->variability = constant;
rem = current_ir_graph;
current_ir_graph = get_const_code_irg();
- res->value = new_Const(mode_p, tarval_p_from_entity(res));
+ res->value = new_Const(mode_P, new_tarval_from_entity(res, mode_P));
current_ir_graph = rem;
} else {
res->variability = uninitialized;
+ res->value = NULL;
+ res->values = NULL;
}
res->peculiarity = existent;
res->volatility = non_volatile;
res->irg = NULL;
+#ifdef DEBUG_libfirm
+ res->nr = get_irp_new_node_nr();
+#endif
+
res->visit = 0;
/* Remember entity in it's owner. */
insert_entity_in_owner (res);
return res;
}
-
+entity *
+new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
+ entity *res = new_entity(owner, name, type);
+ set_entity_dbg_info(res, db);
+ return res;
+}
INLINE void free_entity_attrs(entity *ent) {
assert(ent);
if (get_type_tpop(get_entity_owner(ent)) == type_class) {
new = (entity *) malloc (sizeof (entity));
memcpy (new, old, sizeof (entity));
new->owner = new_owner;
+ /*
if ((get_type_tpop(get_entity_owner(old)) == type_class) &&
(get_type_tpop(new_owner) == type_class)) {
new->overwrites = DUP_ARR_F(entity *, old->overwrites);
new->overwrites = NEW_ARR_F(entity *, 1);
new->overwrittenby = NEW_ARR_F(entity *, 1);
}
+ */
+ if (is_class_type(new_owner)) {
+ new->overwrites = NEW_ARR_F(entity *, 1);
+ new->overwrittenby = NEW_ARR_F(entity *, 1);
+ }
+#ifdef DEBUG_libfirm
+ new->nr = get_irp_new_node_nr();
+#endif
insert_entity_in_owner (new);
memcpy (new, old, sizeof (entity));
new->name = new_name;
new->ld_name = NULL;
- new->overwrites = DUP_ARR_F(entity *, old->overwrites);
- new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
+ if (is_class_type(new->owner)) {
+ new->overwrites = DUP_ARR_F(entity *, old->overwrites);
+ new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
+ }
+#ifdef DEBUG_libfirm
+ new->nr = get_irp_new_node_nr();
+#endif
insert_entity_in_owner (new);
return new;
}
+
void
free_entity (entity *ent) {
+ free_tarval_entity(ent);
free_entity_attrs(ent);
free(ent);
}
+/* Outputs a unique number for this node */
+INLINE long
+get_entity_nr(entity *ent) {
+ assert(ent);
+#ifdef DEBUG_libfirm
+ return ent->nr;
+#else
+ return 0;
+#endif
+}
+
INLINE const char *
get_entity_name (entity *ent) {
assert (ent);
INLINE void
set_entity_visibility (entity *ent, ent_visibility vis) {
- if (vis != local) assert(ent->allocation == static_allocated);
+ if (vis != local)
+ assert((ent->allocation == static_allocated) ||
+ (ent->allocation == automatic_allocated));
+ /* @@@ Test that the owner type is not local, but how??
+ && get_class_visibility(get_entity_owner(ent)) != local));*/
ent->visibility = vis;
}
ent->variability = var;
}
+/* return the name of the variablity */
+const char *get_variability_name(ent_variability var)
+{
+#define X(a) case a: return #a
+ switch (var) {
+ X(uninitialized);
+ X(initialized);
+ X(part_constant);
+ X(constant);
+ default: return "BAD VALUE";
+ }
+#undef X
+}
INLINE ent_volatility
get_entity_volatility (entity *ent) {
ent->volatility = vol;
}
+/* return the name of the volatility */
+const char *get_volatility_name(ent_volatility var)
+{
+#define X(a) case a: return #a
+ switch (var) {
+ X(non_volatile);
+ X(is_volatile);
+ default: return "BAD VALUE";
+ }
+#undef X
+}
+
INLINE peculiarity
get_entity_peculiarity (entity *ent) {
assert (ent);
ent->peculiarity = pec;
}
+/* return the name of the peculiarity */
+const char *get_peculiarity_name(peculiarity var)
+{
+#define X(a) case a: return #a
+ switch (var) {
+ X(description);
+ X(inherited);
+ X(existent);
+ default: return "BAD VALUE";
+ }
+#undef X
+}
+
/* Set has no effect for entities of type method. */
INLINE ir_node *
get_atomic_ent_value(entity *ent) {
case iro_Add:
nn = new_Add(copy_const_value(get_Add_left(n)), copy_const_value(get_Add_right(n)), m); break;
default:
- assert(0 && "opdope invalid or not implemented"); break;
+ assert(0 && "opdope invalid or not implemented");
+ nn=NULL;
+ break;
}
return nn;
}
current_ir_graph = get_const_code_irg();
for (i = 0; i < num_vals; i++) {
- val = new_Const(get_tv_mode (values[i]), values[i]);
+ val = new_Const(get_tarval_mode (values[i]), values[i]);
add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
}
current_ir_graph = rem;
return (ARR_LEN (ent->overwrites))-1;
}
+int
+get_entity_overwrites_index(entity *ent, entity *overwritten) {
+ int i;
+ assert(ent && is_class_type(get_entity_owner(ent)));
+ for (i = 0; i < get_entity_n_overwrites(ent); i++)
+ if (get_entity_overwrites(ent, i) == overwritten)
+ return i;
+ return -1;
+}
+
INLINE entity *
get_entity_overwrites (entity *ent, int pos) {
assert(ent);
ent->overwrites[pos+1] = overwritten;
}
+void
+remove_entity_overwrites(entity *ent, entity *overwritten) {
+ int i;
+ assert(ent && is_class_type(get_entity_owner(ent)));
+ for (i = 1; i < (ARR_LEN (ent->overwrites)); i++)
+ if (ent->overwrites[i] == overwritten) {
+ for(; i < (ARR_LEN (ent->overwrites))-1; i++)
+ ent->overwrites[i] = ent->overwrites[i+1];
+ ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
+ break;
+ }
+}
+
INLINE void
add_entity_overwrittenby (entity *ent, entity *overwrites) {
assert(ent);
return (ARR_LEN (ent->overwrittenby))-1;
}
+int
+get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
+ int i;
+ assert(ent && is_class_type(get_entity_owner(ent)));
+ for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
+ if (get_entity_overwrittenby(ent, i) == overwrites)
+ return i;
+ return -1;
+}
+
INLINE entity *
get_entity_overwrittenby (entity *ent, int pos) {
assert(ent);
ent->overwrittenby[pos+1] = overwrites;
}
+void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
+ int i;
+ assert(ent && is_class_type(get_entity_owner(ent)));
+ for (i = 1; i < (ARR_LEN (ent->overwrittenby)); i++)
+ if (ent->overwrittenby[i] == overwrites) {
+ for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
+ ent->overwrittenby[i] = ent->overwrittenby[i+1];
+ ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
+ break;
+ }
+}
+
/* A link to store intermediate information */
void *
get_entity_link(entity *ent) {
ent->irg = irg;
}
+int is_entity (void *thing) {
+ assert(thing);
+ if (get_kind(thing) == k_entity)
+ return 1;
+ else
+ return 0;
+}
+
int is_atomic_entity(entity *ent) {
type* t = get_entity_type(ent);
return (is_primitive_type(t) || is_pointer_type(t) ||
is_array_type(t) || is_union_type(t));
}
+/* @@@ not implemnted!!! */
bool equal_entity(entity *ent1, entity *ent2) {
+ printf(" calling unimplemented equal entity!!! \n");
return true;
}
-unsigned long get_entity_visited(entity *entity) {
- assert (entity);
- return entity->visit;
+unsigned long get_entity_visited(entity *ent) {
+ assert (ent);
+ return ent->visit;
}
-void set_entity_visited(entity *entity, unsigned long num) {
- assert (entity);
- entity->visit = num;
+void set_entity_visited(entity *ent, unsigned long num) {
+ assert (ent);
+ ent->visit = num;
}
/* Sets visited field in entity to entity_visited. */
-void mark_entity_visited(entity *entity) {
- assert (entity);
- entity->visit = entity_visited;
+void mark_entity_visited(entity *ent) {
+ assert (ent);
+ ent->visit = type_visited;
+}
+
+
+INLINE bool entity_visited(entity *ent) {
+ return get_entity_visited(ent) >= type_visited;
+}
+INLINE bool entity_not_visited(entity *ent) {
+ return get_entity_visited(ent) < type_visited;
}
projects / libfirm / blobdiff