3 * File name: ir/tr/entity.c
4 * Purpose: Representation of all program known entities.
5 * Author: Martin Trapp, Christian Schaefer
6 * Modified by: Goetz Lindenmaier, Michael Beck
9 * Copyright: (c) 1998-2006 Universität Karlsruhe
10 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
32 #include "firm_common_t.h"
43 /* All this is needed to build the constant node for methods: */
47 #include "irdump.h" /* for output if errors occur. */
49 #include "callgraph.h" /* for dumping debug output */
51 /*******************************************************************/
53 /*******************************************************************/
55 entity *unknown_entity = NULL;
57 entity *get_unknown_entity(void) { return unknown_entity; }
59 #define UNKNOWN_ENTITY_NAME "unknown_entity"
61 /*-----------------------------------------------------------------*/
63 /*-----------------------------------------------------------------*/
65 static INLINE void insert_entity_in_owner(entity *ent) {
66 ir_type *owner = ent->owner;
67 switch (get_type_tpop_code(owner)) {
69 add_class_member (owner, ent);
72 add_struct_member (owner, ent);
75 add_union_member (owner, ent);
78 set_array_element_entity(owner, ent);
85 * Creates a new entity. This entity is NOT inserted in the owner type.
87 * @param db debug info for this entity
88 * @param owner the owner type of the new entity
89 * @param name the name of the new entity
90 * @param type the type of the new entity
92 * @return the new created entity
94 static INLINE entity *
95 new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
100 assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
102 res = xmalloc(sizeof(*res));
103 memset(res, 0, sizeof(*res));
105 res->kind = k_entity;
111 res->allocation = allocation_automatic;
112 res->visibility = visibility_local;
113 res->volatility = volatility_non_volatile;
114 res->stickyness = stickyness_unsticky;
115 res->peculiarity = peculiarity_existent;
116 res->compiler_gen = 0;
119 res->repr_class = NULL;
121 if (is_Method_type(type)) {
124 rem = current_ir_graph;
125 current_ir_graph = get_const_code_irg();
126 res->value = new_SymConst(sym, symconst_addr_ent);
127 current_ir_graph = rem;
128 res->allocation = allocation_static;
129 res->variability = variability_constant;
130 res->attr.mtd_attr.irg_add_properties = mtp_property_inherited;
131 res->attr.mtd_attr.vtable_number = VTABLE_NUM_NOT_SET;
132 res->attr.mtd_attr.param_access = NULL;
133 res->attr.mtd_attr.param_weight = NULL;
134 res->attr.mtd_attr.irg = NULL;
135 res->attr.mtd_attr.section = section_text;
137 else if (is_compound_type(type)) {
138 res->variability = variability_uninitialized;
140 res->attr.cmpd_attr.values = NULL;
141 res->attr.cmpd_attr.val_paths = NULL;
144 res->variability = variability_uninitialized;
148 if (is_Class_type(owner)) {
149 res->overwrites = NEW_ARR_F(entity *, 0);
150 res->overwrittenby = NEW_ARR_F(entity *, 0);
152 res->overwrites = NULL;
153 res->overwrittenby = NULL;
157 res->nr = get_irp_new_node_nr();
158 #endif /* DEBUG_libfirm */
161 set_entity_dbg_info(res, db);
167 new_d_entity(ir_type *owner, ident *name, ir_type *type, dbg_info *db) {
170 assert(is_compound_type(owner));
171 res = new_rd_entity(db, owner, name, type);
172 /* Remember entity in it's owner. */
173 insert_entity_in_owner(res);
175 hook_new_entity(res);
180 new_entity(ir_type *owner, ident *name, ir_type *type) {
181 return new_d_entity(owner, name, type, NULL);
185 * Free entity attributes.
187 * @param ent the entity
189 static void free_entity_attrs(entity *ent) {
191 if (get_type_tpop(get_entity_owner(ent)) == type_class) {
192 DEL_ARR_F(ent->overwrites); ent->overwrites = NULL;
193 DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL;
195 assert(ent->overwrites == NULL);
196 assert(ent->overwrittenby == NULL);
198 if (is_compound_entity(ent)) {
199 if (ent->attr.cmpd_attr.val_paths) {
200 for (i = 0; i < get_compound_ent_n_values(ent); i++)
201 if (ent->attr.cmpd_attr.val_paths[i]) {
202 /* free_compound_graph_path(ent->attr.cmpd_attr.val_paths[i]) ; * @@@ warum nich? */
203 /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
204 /* DEL_ARR_F(ent->attr.cmpd_attr.val_paths); */
206 ent->attr.cmpd_attr.val_paths = NULL;
208 /* if (ent->attr.cmpd_attr.values) DEL_ARR_F(ent->attr.cmpd_attr.values); *//* @@@ warum nich? */
209 ent->attr.cmpd_attr.values = NULL;
211 else if (is_method_entity(ent)) {
212 if (ent->attr.mtd_attr.param_access) {
213 DEL_ARR_F(ent->attr.mtd_attr.param_access);
214 ent->attr.mtd_attr.param_access = NULL;
216 if (ent->attr.mtd_attr.param_weight) {
217 DEL_ARR_F(ent->attr.mtd_attr.param_weight);
218 ent->attr.mtd_attr.param_weight = NULL;
224 copy_entity_own(entity *old, ir_type *new_owner) {
226 assert(is_entity(old));
227 assert(is_compound_type(new_owner));
229 if (old->owner == new_owner) return old;
230 newe = xmalloc(sizeof(*newe));
231 memcpy(newe, old, sizeof(*newe));
232 newe->owner = new_owner;
233 if (is_Class_type(new_owner)) {
234 newe->overwrites = NEW_ARR_F(entity *, 0);
235 newe->overwrittenby = NEW_ARR_F(entity *, 0);
238 newe->nr = get_irp_new_node_nr();
241 insert_entity_in_owner(newe);
247 copy_entity_name(entity *old, ident *new_name) {
249 assert(old && old->kind == k_entity);
251 if (old->name == new_name) return old;
252 newe = xmalloc(sizeof(*newe));
253 memcpy(newe, old, sizeof(*newe));
254 newe->name = new_name;
255 newe->ld_name = NULL;
256 if (is_Class_type(newe->owner)) {
257 newe->overwrites = DUP_ARR_F(entity *, old->overwrites);
258 newe->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
261 newe->nr = get_irp_new_node_nr();
264 insert_entity_in_owner (newe);
271 free_entity (entity *ent) {
272 assert(ent && ent->kind == k_entity);
273 free_entity_attrs(ent);
278 /* Outputs a unique number for this node */
280 get_entity_nr(entity *ent) {
281 assert(ent && ent->kind == k_entity);
285 return (long)PTR_TO_INT(ent);
290 (get_entity_name)(const entity *ent) {
291 return _get_entity_name(ent);
295 (get_entity_ident)(const entity *ent) {
296 return _get_entity_ident(ent);
300 (set_entity_ident)(entity *ent, ident *id) {
301 _set_entity_ident(ent, id);
305 (get_entity_owner)(entity *ent) {
306 return _get_entity_owner(ent);
310 set_entity_owner(entity *ent, ir_type *owner) {
311 assert(is_entity(ent));
312 assert(is_compound_type(owner));
317 (get_entity_ld_ident)(entity *ent) {
318 return _get_entity_ld_ident(ent);
322 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
323 _set_entity_ld_ident(ent, ld_ident);
327 (get_entity_ld_name)(entity *ent) {
328 return _get_entity_ld_name(ent);
332 (get_entity_type)(entity *ent) {
333 return _get_entity_type(ent);
337 (set_entity_type)(entity *ent, ir_type *type) {
338 _set_entity_type(ent, type);
342 (get_entity_allocation)(const entity *ent) {
343 return _get_entity_allocation(ent);
347 (set_entity_allocation)(entity *ent, ir_allocation al) {
348 _set_entity_allocation(ent, al);
351 /* return the name of the visibility */
352 const char *get_allocation_name(ir_allocation all)
354 #define X(a) case a: return #a
356 X(allocation_automatic);
357 X(allocation_parameter);
358 X(allocation_dynamic);
359 X(allocation_static);
360 default: return "BAD VALUE";
367 (get_entity_visibility)(const entity *ent) {
368 return _get_entity_visibility(ent);
372 set_entity_visibility(entity *ent, ir_visibility vis) {
373 assert(ent && ent->kind == k_entity);
374 if (vis != visibility_local)
375 assert((ent->allocation == allocation_static) ||
376 (ent->allocation == allocation_automatic));
377 /* @@@ Test that the owner type is not local, but how??
378 && get_class_visibility(get_entity_owner(ent)) != local));*/
379 ent->visibility = vis;
382 /* return the name of the visibility */
383 const char *get_visibility_name(ir_visibility vis)
385 #define X(a) case a: return #a
388 X(visibility_external_visible);
389 X(visibility_external_allocated);
390 default: return "BAD VALUE";
396 (get_entity_variability)(const entity *ent) {
397 return _get_entity_variability(ent);
401 set_entity_variability (entity *ent, ir_variability var)
403 assert(ent && ent->kind == k_entity);
404 if (var == variability_part_constant)
405 assert(is_Class_type(ent->type) || is_Struct_type(ent->type));
407 if ((is_compound_type(ent->type)) &&
408 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
409 /* Allocate data structures for constant values */
410 ent->attr.cmpd_attr.values = NEW_ARR_F(ir_node *, 0);
411 ent->attr.cmpd_attr.val_paths = NEW_ARR_F(compound_graph_path *, 0);
413 if ((is_atomic_type(ent->type)) &&
414 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
415 /* Set default constant value. */
416 ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type));
419 if ((is_compound_type(ent->type)) &&
420 (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
421 /* Free data structures for constant values */
422 DEL_ARR_F(ent->attr.cmpd_attr.values); ent->attr.cmpd_attr.values = NULL;
423 DEL_ARR_F(ent->attr.cmpd_attr.val_paths); ent->attr.cmpd_attr.val_paths = NULL;
425 ent->variability = var;
428 /* return the name of the variability */
429 const char *get_variability_name(ir_variability var)
431 #define X(a) case a: return #a
433 X(variability_uninitialized);
434 X(variability_initialized);
435 X(variability_part_constant);
436 X(variability_constant);
437 default: return "BAD VALUE";
443 (get_entity_volatility)(const entity *ent) {
444 return _get_entity_volatility(ent);
448 (set_entity_volatility)(entity *ent, ir_volatility vol) {
449 _set_entity_volatility(ent, vol);
452 /* return the name of the volatility */
453 const char *get_volatility_name(ir_volatility var)
455 #define X(a) case a: return #a
457 X(volatility_non_volatile);
458 X(volatility_is_volatile);
459 default: return "BAD VALUE";
465 (get_entity_peculiarity)(const entity *ent) {
466 return _get_entity_peculiarity(ent);
470 (set_entity_peculiarity)(entity *ent, ir_peculiarity pec) {
471 _set_entity_peculiarity(ent, pec);
474 /* Checks if an entity is compiler generated */
475 int is_entity_compiler_generated(const entity *ent) {
476 assert(is_entity(ent));
477 return ent->compiler_gen;
480 /* Sets/resets the compiler generated flag */
481 void set_entity_compiler_generated(entity *ent, int flag) {
482 assert(is_entity(ent));
483 ent->compiler_gen = flag ? 1 : 0;
486 /* Get the entity's stickyness */
488 (get_entity_stickyness)(const entity *ent) {
489 return _get_entity_stickyness(ent);
492 /* Set the entity's stickyness */
494 (set_entity_stickyness)(entity *ent, ir_stickyness stickyness) {
495 _set_entity_stickyness(ent, stickyness);
498 /* Set has no effect for existent entities of type method. */
500 get_atomic_ent_value(entity *ent)
502 assert(ent && is_atomic_entity(ent));
503 assert(ent->variability != variability_uninitialized);
504 return skip_Id (ent->value);
508 set_atomic_ent_value(entity *ent, ir_node *val) {
509 assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
510 if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
515 /* Returns true if the the node is representable as code on
517 int is_irn_const_expression(ir_node *n) {
520 /* we are in danger iff an exception will arise. TODO: be more precisely,
521 * for instance Div. will NOT rise if divisor != 0
523 if (is_binop(n) && !is_fragile_op(n))
524 return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
527 switch(get_irn_opcode(n)) {
534 return is_irn_const_expression(get_irn_n(n, 0));
542 * Copies a firm subgraph that complies to the restrictions for
543 * constant expressions to current_block in current_ir_graph.
545 ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
549 /* @@@ GL I think we should implement this using the routines from irgopt for
550 dead node elimination/inlineing. */
553 switch (get_irn_opcode(n)) {
555 nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
558 nn = new_d_SymConst_type(dbg, get_SymConst_symbol(n), get_SymConst_kind(n),
559 get_SymConst_value_type(n));
562 nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)),
563 copy_const_value(dbg, get_Add_right(n)), m); break;
565 nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)),
566 copy_const_value(dbg, get_Sub_right(n)), m); break;
568 nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)),
569 copy_const_value(dbg, get_Mul_right(n)), m); break;
571 nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)),
572 copy_const_value(dbg, get_And_right(n)), m); break;
574 nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)),
575 copy_const_value(dbg, get_Or_right(n)), m); break;
577 nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)),
578 copy_const_value(dbg, get_Eor_right(n)), m); break;
580 nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break;
582 nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break;
584 nn = new_d_Unknown(m); break;
587 assert(0 && "opcode invalid or not implemented");
594 /* Creates a new compound graph path. */
595 compound_graph_path *
596 new_compound_graph_path(ir_type *tp, int length) {
597 compound_graph_path *res;
599 assert(is_compound_type(tp));
602 res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->list[0]));
603 memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->list[0]));
604 res->kind = k_ir_compound_graph_path;
611 /* Frees an graph path object */
612 void free_compound_graph_path (compound_graph_path *gr) {
613 assert(gr && is_compound_graph_path(gr));
618 /* Returns non-zero if an object is a compound graph path */
619 int is_compound_graph_path(void *thing) {
620 return (get_kind(thing) == k_ir_compound_graph_path);
623 /* Checks whether the path up to pos is correct. If the path contains a NULL,
624 * assumes the path is not complete and returns 'true'. */
625 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
628 ir_type *owner = gr->tp;
630 for (i = 0; i <= pos; i++) {
631 node = get_compound_graph_path_node(gr, i);
633 /* Path not yet complete. */
635 if (get_entity_owner(node) != owner)
637 owner = get_entity_type(node);
639 if (pos == get_compound_graph_path_length(gr))
640 if (!is_atomic_type(owner))
645 /* Returns the length of a graph path */
646 int get_compound_graph_path_length(compound_graph_path *gr) {
647 assert(gr && is_compound_graph_path(gr));
652 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
653 assert(gr && is_compound_graph_path(gr));
654 assert(pos >= 0 && pos < gr->len);
655 return gr->list[pos].node;
659 set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
660 assert(gr && is_compound_graph_path(gr));
661 assert(pos >= 0 && pos < gr->len);
662 assert(is_entity(node));
663 gr->list[pos].node = node;
664 assert(is_proper_compound_graph_path(gr, pos));
668 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
669 assert(gr && is_compound_graph_path(gr));
670 assert(pos >= 0 && pos < gr->len);
671 return gr->list[pos].index;
675 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
676 assert(gr && is_compound_graph_path(gr));
677 assert(pos >= 0 && pos < gr->len);
678 gr->list[pos].index = index;
681 /* A value of a compound entity is a pair of value and the corresponding path to a member of
684 add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
685 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
686 assert(is_compound_graph_path(path));
687 ARR_APP1(ir_node *, ent->attr.cmpd_attr.values, val);
688 ARR_APP1(compound_graph_path *, ent->attr.cmpd_attr.val_paths, path);
692 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
693 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
694 assert(is_compound_graph_path(path));
695 assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
696 ent->attr.cmpd_attr.values[pos] = val;
697 ent->attr.cmpd_attr.val_paths[pos] = path;
701 get_compound_ent_n_values(entity *ent) {
702 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
703 return ARR_LEN(ent->attr.cmpd_attr.values);
707 get_compound_ent_value(entity *ent, int pos) {
708 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
709 assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
710 return ent->attr.cmpd_attr.values[pos];
713 compound_graph_path *
714 get_compound_ent_value_path(entity *ent, int pos) {
715 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
716 assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.val_paths));
717 return ent->attr.cmpd_attr.val_paths[pos];
721 * Returns non-zero, if two compound_graph_pathes are equal
723 static int equal_paths(compound_graph_path *path1, int *visited_indicees, compound_graph_path *path2) {
725 int len1 = get_compound_graph_path_length(path1);
726 int len2 = get_compound_graph_path_length(path2);
728 if (len2 > len1) return 0;
730 for (i = 0; i < len1; i++) {
732 entity *node1 = get_compound_graph_path_node(path1, i);
733 entity *node2 = get_compound_graph_path_node(path2, i);
735 if (node1 != node2) return 0;
737 tp = get_entity_owner(node1);
738 if (is_Array_type(tp)) {
741 /* Compute the index of this node. */
742 assert(get_array_n_dimensions(tp) == 1 && "multidim not implemented");
744 low = get_array_lower_bound_int(tp, 0);
745 if (low + visited_indicees[i] < get_compound_graph_path_array_index(path2, i)) {
746 visited_indicees[i]++;
750 assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
756 /* Returns the position of a value with the given path.
757 * The path must contain array indicees for all array element entities. */
758 int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
759 int i, n_paths = get_compound_ent_n_values(ent);
760 int *visited_indicees;
761 int path_len = get_compound_graph_path_length(path);
763 NEW_ARR_A(int *, visited_indicees, path_len);
764 memset(visited_indicees, 0, sizeof(*visited_indicees) * path_len);
765 for (i = 0; i < n_paths; i ++) {
766 if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, path))
773 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
774 printf("Entity %s : ", get_entity_name(ent));
775 for (j = 0; j < get_compound_graph_path_length(path); ++j) {
776 entity *node = get_compound_graph_path_node(path, j);
777 printf("%s", get_entity_name(node));
778 if (is_Array_type(get_entity_owner(node)))
779 printf("[%d]", get_compound_graph_path_array_index(path, j));
781 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
785 assert(0 && "path not found");
789 /* Returns a constant value given the access path.
790 * The path must contain array indicees for all array element entities. */
791 ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path) {
792 return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
797 remove_compound_ent_value(entity *ent, entity *value_ent) {
799 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
800 for (i = 0; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths)); ++i) {
801 compound_graph_path *path = ent->attr.cmpd_attr.val_paths[i];
802 if (path->list[path->len-1].node == value_ent) {
803 for (; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths))-1; ++i) {
804 ent->attr.cmpd_attr.val_paths[i] = ent->attr.cmpd_attr.val_paths[i+1];
805 ent->attr.cmpd_attr.values[i] = ent->attr.cmpd_attr.values[i+1];
807 ARR_SETLEN(entity*, ent->attr.cmpd_attr.val_paths, ARR_LEN(ent->attr.cmpd_attr.val_paths) - 1);
808 ARR_SETLEN(ir_node*, ent->attr.cmpd_attr.values, ARR_LEN(ent->attr.cmpd_attr.values) - 1);
815 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
816 compound_graph_path *path;
817 ir_type *owner_tp = get_entity_owner(member);
818 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
819 path = new_compound_graph_path(get_entity_type(ent), 1);
820 path->list[0].node = member;
821 if (is_Array_type(owner_tp)) {
825 assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
826 max = get_array_lower_bound_int(owner_tp, 0) -1;
827 for (i = 0, n = get_compound_ent_n_values(ent); i < n; ++i) {
828 int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
833 path->list[0].index = max + 1;
835 add_compound_ent_value_w_path(ent, val, path);
838 /* Copies the firm subgraph referenced by val to const_code_irg and adds
839 the node as constant initialization to ent.
840 The subgraph may not contain control flow operations.
842 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
843 ir_graph *rem = current_ir_graph;
845 assert(get_entity_variability(ent) != variability_uninitialized);
846 current_ir_graph = get_const_code_irg();
848 val = copy_const_value(val);
849 add_compound_ent_value(ent, val, member);
850 current_ir_graph = rem;
853 /* Copies the value i of the entity to current_block in current_ir_graph.
855 copy_compound_ent_value(entity *ent, int pos) {
856 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
857 return copy_const_value(ent->values[pos+1]);
861 get_compound_ent_value_member(entity *ent, int pos) {
862 compound_graph_path *path;
863 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
864 path = get_compound_ent_value_path(ent, pos);
866 return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
870 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
871 compound_graph_path *path;
872 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
873 path = get_compound_ent_value_path(ent, pos);
874 set_compound_graph_path_node(path, 0, member);
875 set_compound_ent_value_w_path(ent, val, path, pos);
879 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
881 ir_graph *rem = current_ir_graph;
882 ir_type *arrtp = get_entity_type(ent);
884 ir_type *elttp = get_array_element_type(arrtp);
886 assert(is_Array_type(arrtp));
887 assert(get_array_n_dimensions(arrtp) == 1);
888 /* One bound is sufficient, the number of constant fields makes the
890 assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
891 assert(get_entity_variability(ent) != variability_uninitialized);
892 current_ir_graph = get_const_code_irg();
894 for (i = 0; i < num_vals; i++) {
895 val = new_Const_type(values[i], elttp);
896 add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
897 set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
899 current_ir_graph = rem;
902 int get_compound_ent_value_offset_bits(entity *ent, int pos) {
903 compound_graph_path *path;
907 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
909 path = get_compound_ent_value_path(ent, pos);
910 path_len = get_compound_graph_path_length(path);
912 for (i = 0; i < path_len; ++i) {
913 entity *node = get_compound_graph_path_node(path, i);
914 ir_type *node_tp = get_entity_type(node);
915 ir_type *owner_tp = get_entity_owner(node);
916 if (is_Array_type(owner_tp)) {
917 int size = get_type_size_bits(node_tp);
918 int align = get_type_alignment_bits(node_tp);
922 assert(size % align == 0);
923 /* ansonsten aufrunden */
925 offset += size * get_compound_graph_path_array_index(path, i);
927 offset += get_entity_offset_bits(node);
933 int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
934 int offset = get_compound_ent_value_offset_bits(ent, pos);
935 assert(offset % 8 == 0);
940 static void init_index(ir_type *arr) {
944 assert(get_array_n_dimensions(arr) == 1);
946 if (has_array_lower_bound(arr, dim))
947 init = get_array_lower_bound_int(arr, 0) -1;
949 init = get_array_upper_bound_int(arr, 0) +1;
951 set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
955 static int get_next_index(entity *elem_ent) {
956 ir_type *arr = get_entity_owner(elem_ent);
960 assert(get_array_n_dimensions(arr) == 1);
962 if (has_array_lower_bound(arr, dim)) {
963 next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
964 if (has_array_upper_bound(arr, dim)) {
965 int upper = get_array_upper_bound_int(arr, dim);
966 if (next == upper) next = get_array_lower_bound_int(arr, dim);
969 next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
970 if (has_array_lower_bound(arr, dim)) {
971 int upper = get_array_upper_bound_int(arr, dim);
972 if (next == upper) next = get_array_upper_bound_int(arr, dim);
976 set_entity_link(elem_ent, INT_TO_PTR(next));
980 /* Compute the array indices in compound graph paths of initialized entities.
982 * All arrays must have fixed lower and upper bounds. One array can
983 * have an open bound. If there are several open bounds, we do
984 * nothing. There must be initializer elements for all array
985 * elements. Uses the link field in the array element entities. The
986 * array bounds must be representable as ints.
988 * (If the bounds are not representable as ints we have to represent
989 * the indices as firm nodes. But still we must be able to
990 * evaluate the index against the upper bound.)
992 void compute_compound_ent_array_indicees(entity *ent) {
993 ir_type *tp = get_entity_type(ent);
995 entity *unknown_bound_entity = NULL;
997 if (!is_compound_type(tp) ||
998 (ent->variability == variability_uninitialized)) return ;
1000 n_vals = get_compound_ent_n_values(ent);
1001 if (n_vals == 0) return;
1003 /* We can not compute the indexes if there is more than one array
1004 with an unknown bound. For this remember the first entity that
1005 represents such an array. It could be ent. */
1006 if (is_Array_type(tp)) {
1009 assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
1010 if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
1011 unknown_bound_entity = ent;
1014 /* Initialize the entity links to lower bound -1 and test all path elements
1015 for known bounds. */
1016 for (i = 0; i < n_vals; ++i) {
1017 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1018 int j, path_len = get_compound_graph_path_length(path);
1019 for (j = 0; j < path_len; ++j) {
1020 entity *node = get_compound_graph_path_node(path, j);
1021 ir_type *elem_tp = get_entity_type(node);
1023 if (is_Array_type(elem_tp)) {
1025 assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
1026 if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
1027 if (!unknown_bound_entity) unknown_bound_entity = node;
1028 if (node != unknown_bound_entity) return;
1031 init_index(elem_tp);
1036 /* Finally compute the indexes ... */
1037 for (i = 0; i < n_vals; ++i) {
1038 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1039 int j, path_len = get_compound_graph_path_length(path);
1040 for (j = 0; j < path_len; ++j) {
1041 entity *node = get_compound_graph_path_node(path, j);
1042 ir_type *owner_tp = get_entity_owner(node);
1043 if (is_Array_type(owner_tp))
1044 set_compound_graph_path_array_index (path, j, get_next_index(node));
1049 /** resize: double the allocated buffer */
1050 static int *resize (int *buf, int *size) {
1051 int new_size = *size * 2;
1052 int *new_buf = xcalloc(new_size, sizeof(new_buf[0]));
1053 memcpy(new_buf, buf, *size);
1059 /* We sort the elements by placing them at their bit offset in an
1060 array where each entry represents one bit called permutation. In
1061 fact, we do not place the values themselves, as we would have to
1062 copy two things, the value and the path. We only remember the
1063 position in the old order. Each value should have a distinct
1064 position in the permutation.
1066 A second iteration now permutes the actual elements into two
1068 void sort_compound_ent_values(entity *ent) {
1076 ir_node **my_values;
1077 compound_graph_path **my_paths;
1079 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
1081 tp = get_entity_type(ent);
1082 n_vals = get_compound_ent_n_values(ent);
1083 tp_size = get_type_size_bits(tp);
1085 if (!is_compound_type(tp) ||
1086 (ent->variability == variability_uninitialized) ||
1087 (get_type_state(tp) != layout_fixed) ||
1088 (n_vals == 0) ) return;
1090 /* estimated upper bound for size. Better: use flexible array ... */
1091 size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
1092 permutation = xcalloc(size, sizeof(permutation[0]));
1094 for (i = 0; i < n_vals; ++i) {
1095 int pos = get_compound_ent_value_offset_bits(ent, i);
1096 while (pos >= size) {
1097 permutation = resize(permutation, &size);
1100 assert(permutation[pos] == 0 && "two values with the same offset");
1101 permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
1102 So inc all entries by one. */
1103 //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
1107 my_values = NEW_ARR_F(ir_node *, n_vals);
1108 my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
1109 for (i = 0; i < size; ++i) {
1110 int pos = permutation[i];
1112 //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next);
1113 assert(next < n_vals);
1114 pos--; /* We increased the pos by one */
1115 my_values[next] = get_compound_ent_value (ent, pos);
1116 my_paths [next] = get_compound_ent_value_path(ent, pos);
1122 DEL_ARR_F(ent->attr.cmpd_attr.values);
1123 ent->attr.cmpd_attr.values = my_values;
1124 DEL_ARR_F(ent->attr.cmpd_attr.val_paths);
1125 ent->attr.cmpd_attr.val_paths = my_paths;
1129 (get_entity_offset_bytes)(const entity *ent) {
1130 return _get_entity_offset_bytes(ent);
1134 (get_entity_offset_bits)(const entity *ent) {
1135 return _get_entity_offset_bits(ent);
1139 (set_entity_offset_bytes)(entity *ent, int offset) {
1140 _set_entity_offset_bytes(ent, offset);
1144 (set_entity_offset_bits)(entity *ent, int offset) {
1145 _set_entity_offset_bits(ent, offset);
1149 add_entity_overwrites(entity *ent, entity *overwritten) {
1150 assert(is_Class_type(get_entity_owner(ent)));
1151 ARR_APP1(entity *, ent->overwrites, overwritten);
1152 ARR_APP1(entity *, overwritten->overwrittenby, ent);
1156 get_entity_n_overwrites(entity *ent) {
1157 assert(is_Class_type(get_entity_owner(ent)));
1158 return (ARR_LEN(ent->overwrites));
1162 get_entity_overwrites_index(entity *ent, entity *overwritten) {
1164 assert(is_Class_type(get_entity_owner(ent)));
1165 for (i = 0; i < get_entity_n_overwrites(ent); i++)
1166 if (get_entity_overwrites(ent, i) == overwritten)
1172 get_entity_overwrites (entity *ent, int pos) {
1173 assert(is_Class_type(get_entity_owner(ent)));
1174 assert(pos < get_entity_n_overwrites(ent));
1175 return ent->overwrites[pos];
1179 set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
1180 assert(is_Class_type(get_entity_owner(ent)));
1181 assert(pos < get_entity_n_overwrites(ent));
1182 ent->overwrites[pos] = overwritten;
1186 remove_entity_overwrites(entity *ent, entity *overwritten) {
1188 assert(is_Class_type(get_entity_owner(ent)));
1189 for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1190 if (ent->overwrites[i] == overwritten) {
1191 for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1192 ent->overwrites[i] = ent->overwrites[i+1];
1193 ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1199 add_entity_overwrittenby (entity *ent, entity *overwrites) {
1200 assert(is_Class_type(get_entity_owner(ent)));
1201 add_entity_overwrites(overwrites, ent);
1205 get_entity_n_overwrittenby (entity *ent) {
1206 assert(is_Class_type(get_entity_owner(ent)));
1207 return (ARR_LEN (ent->overwrittenby));
1211 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1213 assert(is_Class_type(get_entity_owner(ent)));
1214 for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1215 if (get_entity_overwrittenby(ent, i) == overwrites)
1221 get_entity_overwrittenby (entity *ent, int pos) {
1222 assert(is_Class_type(get_entity_owner(ent)));
1223 assert(pos < get_entity_n_overwrittenby(ent));
1224 return ent->overwrittenby[pos];
1228 set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
1229 assert(is_Class_type(get_entity_owner(ent)));
1230 assert(pos < get_entity_n_overwrittenby(ent));
1231 ent->overwrittenby[pos] = overwrites;
1234 void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1236 assert(is_Class_type(get_entity_owner(ent)));
1237 for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1238 if (ent->overwrittenby[i] == overwrites) {
1239 for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1240 ent->overwrittenby[i] = ent->overwrittenby[i+1];
1241 ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1246 /* A link to store intermediate information */
1248 (get_entity_link)(const entity *ent) {
1249 return _get_entity_link(ent);
1253 (set_entity_link)(entity *ent, void *l) {
1254 _set_entity_link(ent, l);
1258 (get_entity_irg)(const entity *ent) {
1259 return _get_entity_irg(ent);
1263 set_entity_irg(entity *ent, ir_graph *irg) {
1264 assert(is_method_entity(ent));
1265 /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1266 * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1267 * aber erhalten bleiben soll? Wandle die Entitaet in description oder
1270 assert((irg && ent->peculiarity == peculiarity_existent) ||
1271 (!irg && (ent->peculiarity == peculiarity_existent)
1272 && (ent -> visibility == visibility_external_allocated)) ||
1273 (!irg && ent->peculiarity == peculiarity_description) ||
1274 (!irg && ent->peculiarity == peculiarity_inherited));
1275 ent->attr.mtd_attr.irg = irg;
1278 unsigned get_entity_vtable_number(entity *ent) {
1279 assert(is_method_entity(ent));
1280 return ent->attr.mtd_attr.vtable_number;
1283 void set_entity_vtable_number(entity *ent, unsigned vtable_number) {
1284 assert(is_method_entity(ent));
1285 ent->attr.mtd_attr.vtable_number = vtable_number;
1288 /* Returns the section of a method. */
1289 ir_img_section get_method_img_section(const entity *ent) {
1290 assert(is_method_entity(ent));
1291 return ent->attr.mtd_attr.section;
1294 /* Sets the section of a method. */
1295 void set_method_img_section(entity *ent, ir_img_section section) {
1296 assert(is_method_entity(ent));
1297 ent->attr.mtd_attr.section = section;
1301 (is_entity)(const void *thing) {
1302 return _is_entity(thing);
1305 int is_atomic_entity(entity *ent) {
1306 ir_type *t = get_entity_type(ent);
1307 const tp_op *op = get_type_tpop(t);
1308 return (op == type_primitive || op == type_pointer ||
1309 op == type_enumeration || op == type_method);
1312 int is_compound_entity(entity *ent) {
1313 ir_type *t = get_entity_type(ent);
1314 const tp_op *op = get_type_tpop(t);
1315 return (op == type_class || op == type_struct ||
1316 op == type_array || op == type_union);
1319 int is_method_entity(entity *ent) {
1320 ir_type *t = get_entity_type(ent);
1321 return is_Method_type(t);
1325 * @todo not implemented!!! */
1326 int equal_entity(entity *ent1, entity *ent2) {
1327 fprintf(stderr, " calling unimplemented equal entity!!! \n");
1332 unsigned long (get_entity_visited)(entity *ent) {
1333 return _get_entity_visited(ent);
1336 void (set_entity_visited)(entity *ent, unsigned long num) {
1337 _set_entity_visited(ent, num);
1340 /* Sets visited field in entity to entity_visited. */
1341 void (mark_entity_visited)(entity *ent) {
1342 _mark_entity_visited(ent);
1345 int (entity_visited)(entity *ent) {
1346 return _entity_visited(ent);
1349 int (entity_not_visited)(entity *ent) {
1350 return _entity_not_visited(ent);
1353 /* Returns the mask of the additional entity properties. */
1354 unsigned get_entity_additional_properties(entity *ent) {
1357 assert(is_method_entity(ent));
1359 /* first check, if the graph has additional properties */
1360 irg = get_entity_irg(ent);
1363 return get_irg_additional_properties(irg);
1365 if (ent->attr.mtd_attr.irg_add_properties & mtp_property_inherited)
1366 return get_method_additional_properties(get_entity_type(ent));
1368 return ent->attr.mtd_attr.irg_add_properties;
1371 /* Sets the mask of the additional graph properties. */
1372 void set_entity_additional_properties(entity *ent, unsigned property_mask)
1376 assert(is_method_entity(ent));
1378 /* first check, if the graph exists */
1379 irg = get_entity_irg(ent);
1381 set_irg_additional_properties(irg, property_mask);
1383 /* do not allow to set the mtp_property_inherited flag or
1384 * the automatic inheritance of flags will not work */
1385 ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited;
1389 /* Sets one additional graph property. */
1390 void set_entity_additional_property(entity *ent, mtp_additional_property flag)
1394 assert(is_method_entity(ent));
1396 /* first check, if the graph exists */
1397 irg = get_entity_irg(ent);
1399 set_irg_additional_property(irg, flag);
1401 unsigned mask = ent->attr.mtd_attr.irg_add_properties;
1403 if (mask & mtp_property_inherited)
1404 mask = get_method_additional_properties(get_entity_type(ent));
1406 /* do not allow to set the mtp_property_inherited flag or
1407 * the automatic inheritance of flags will not work */
1408 ent->attr.mtd_attr.irg_add_properties = mask | (flag & ~mtp_property_inherited);
1412 /* Returns the class type that this type info entity represents or NULL
1413 if ent is no type info entity. */
1414 ir_type *(get_entity_repr_class)(const entity *ent) {
1415 return _get_entity_repr_class(ent);
1418 /* Initialize entity module. */
1419 void firm_init_entity(void)
1421 symconst_symbol sym;
1423 assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
1424 assert(!unknown_entity && "Call firm_init_entity() only once!");
1426 unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
1427 set_entity_visibility(unknown_entity, visibility_external_allocated);
1428 set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
1430 current_ir_graph = get_const_code_irg();
1431 sym.entity_p = unknown_entity;
1432 unknown_entity->value = new_SymConst(sym, symconst_addr_ent);