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
9 * Copyright: (c) 1998-2003 Universität Karlsruhe
10 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
24 #include "firm_common_t.h"
27 # include "entity_t.h"
29 # include "typegmod.h"
34 /* All this is needed to build the constant node for methods: */
35 # include "irprog_t.h"
40 # include "irdump.h" /* for output if errors occur. */
43 # include "callgraph.h" /* for dumping debug output */
45 /*******************************************************************/
47 /*******************************************************************/
49 entity *unknown_entity = NULL;
51 entity *get_unknown_entity(void) { return unknown_entity; }
53 #define UNKNOWN_ENTITY_NAME "unknown_entity"
55 /*-----------------------------------------------------------------*/
57 /*-----------------------------------------------------------------*/
59 static INLINE void insert_entity_in_owner (entity *ent) {
60 ir_type *owner = ent->owner;
61 switch (get_type_tpop_code(owner)) {
63 add_class_member (owner, ent);
66 add_struct_member (owner, ent);
69 add_union_member (owner, ent);
72 set_array_element_entity(owner, ent);
79 * Creates a new entity. This entity is NOT inserted in the owner type.
81 * @param db debug info for this entity
82 * @param owner the owner type of the new entity
83 * @param name the name of the new entity
84 * @param type the type of the new entity
86 * @return the new created entity
88 static INLINE entity *
89 new_rd_entity (dbg_info *db, ir_type *owner, ident *name, ir_type *type)
94 assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
96 res = xmalloc(sizeof(*res));
97 memset(res, 0, sizeof(*res));
105 if (get_type_tpop(type) == type_method)
106 res->allocation = allocation_static;
108 res->allocation = allocation_automatic;
110 res->visibility = visibility_local;
111 res->volatility = volatility_non_volatile;
112 res->stickyness = stickyness_unsticky;
114 res->peculiarity = peculiarity_existent;
118 if (is_Method_type(type)) {
121 rem = current_ir_graph;
122 current_ir_graph = get_const_code_irg();
123 res->value = new_SymConst(sym, symconst_addr_ent);
124 current_ir_graph = rem;
125 res->variability = variability_constant;
126 res->attr.mtd_attr.irg_add_properties = mtp_property_inherited;
127 res->attr.mtd_attr.vtable_number = VTABLE_NUM_NOT_SET;
128 res->attr.mtd_attr.param_access = NULL;
129 res->attr.mtd_attr.param_weight = NULL;
130 res->attr.mtd_attr.irg = NULL;
132 else if (is_compound_type(type)) {
133 res->variability = variability_uninitialized;
135 res->attr.cmpd_attr.values = NULL;
136 res->attr.cmpd_attr.val_paths = NULL;
139 res->variability = variability_uninitialized;
143 if (is_Class_type(owner)) {
144 res->overwrites = NEW_ARR_F(entity *, 0);
145 res->overwrittenby = NEW_ARR_F(entity *, 0);
147 res->overwrites = NULL;
148 res->overwrittenby = NULL;
152 res->nr = get_irp_new_node_nr();
153 #endif /* DEBUG_libfirm */
156 set_entity_dbg_info(res, db);
162 new_d_entity (ir_type *owner, ident *name, ir_type *type, dbg_info *db) {
165 assert_legal_owner_of_ent(owner);
166 res = new_rd_entity(db, owner, name, type);
167 /* Remember entity in it's owner. */
168 insert_entity_in_owner (res);
170 hook_new_entity(res);
175 new_entity (ir_type *owner, ident *name, ir_type *type) {
176 return new_d_entity(owner, name, type, NULL);
180 * Free entity attributes.
182 * @param ent the entity
184 static void free_entity_attrs(entity *ent) {
186 if (get_type_tpop(get_entity_owner(ent)) == type_class) {
187 DEL_ARR_F(ent->overwrites); ent->overwrites = NULL;
188 DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL;
190 assert(ent->overwrites == NULL);
191 assert(ent->overwrittenby == NULL);
193 if (is_compound_entity(ent)) {
194 if (ent->attr.cmpd_attr.val_paths) {
195 for (i = 0; i < get_compound_ent_n_values(ent); i++)
196 if (ent->attr.cmpd_attr.val_paths[i]) {
197 /* free_compound_graph_path(ent->attr.cmpd_attr.val_paths[i]) ; * @@@ warum nich? */
198 /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
199 /* DEL_ARR_F(ent->attr.cmpd_attr.val_paths); */
201 ent->attr.cmpd_attr.val_paths = NULL;
203 /* if (ent->attr.cmpd_attr.values) DEL_ARR_F(ent->attr.cmpd_attr.values); *//* @@@ warum nich? */
204 ent->attr.cmpd_attr.values = NULL;
206 else if (is_method_entity(ent)) {
207 if (ent->attr.mtd_attr.param_access) {
208 DEL_ARR_F(ent->attr.mtd_attr.param_access);
209 ent->attr.mtd_attr.param_access = NULL;
211 if (ent->attr.mtd_attr.param_weight) {
212 DEL_ARR_F(ent->attr.mtd_attr.param_weight);
213 ent->attr.mtd_attr.param_weight = NULL;
219 copy_entity_own (entity *old, ir_type *new_owner) {
221 assert(old && old->kind == k_entity);
222 assert_legal_owner_of_ent(new_owner);
224 if (old->owner == new_owner) return old;
225 newe = xmalloc(sizeof(*newe));
226 memcpy (newe, old, sizeof(*newe));
227 newe->owner = new_owner;
228 if (is_Class_type(new_owner)) {
229 newe->overwrites = NEW_ARR_F(entity *, 0);
230 newe->overwrittenby = NEW_ARR_F(entity *, 0);
233 newe->nr = get_irp_new_node_nr();
236 insert_entity_in_owner (newe);
242 copy_entity_name (entity *old, ident *new_name) {
244 assert(old && old->kind == k_entity);
246 if (old->name == new_name) return old;
247 newe = xmalloc(sizeof(*newe));
248 memcpy(newe, old, sizeof(*newe));
249 newe->name = new_name;
250 newe->ld_name = NULL;
251 if (is_Class_type(newe->owner)) {
252 newe->overwrites = DUP_ARR_F(entity *, old->overwrites);
253 newe->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
256 newe->nr = get_irp_new_node_nr();
259 insert_entity_in_owner (newe);
266 free_entity (entity *ent) {
267 assert(ent && ent->kind == k_entity);
268 free_entity_attrs(ent);
273 /* Outputs a unique number for this node */
275 get_entity_nr(entity *ent) {
276 assert(ent && ent->kind == k_entity);
280 return (long)PTR_TO_INT(ent);
285 (get_entity_name)(const entity *ent) {
286 return _get_entity_name(ent);
290 (get_entity_ident)(const entity *ent) {
291 return get_entity_ident(ent);
295 (get_entity_owner)(entity *ent) {
296 return _get_entity_owner(ent);
300 set_entity_owner (entity *ent, ir_type *owner) {
301 assert(ent && ent->kind == k_entity);
302 assert_legal_owner_of_ent(owner);
306 void /* should this go into type.c? */
307 assert_legal_owner_of_ent(ir_type *owner) {
308 assert(get_type_tpop_code(owner) == tpo_class ||
309 get_type_tpop_code(owner) == tpo_union ||
310 get_type_tpop_code(owner) == tpo_struct ||
311 get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity
312 -- to select fields! */
316 (get_entity_ld_ident)(entity *ent) {
317 return _get_entity_ld_ident(ent);
321 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
322 _set_entity_ld_ident(ent, ld_ident);
326 (get_entity_ld_name)(entity *ent) {
327 return _get_entity_ld_name(ent);
331 (get_entity_type)(entity *ent) {
332 return _get_entity_type(ent);
336 (set_entity_type)(entity *ent, ir_type *type) {
337 _set_entity_type(ent, type);
341 (get_entity_allocation)(const entity *ent) {
342 return _get_entity_allocation(ent);
346 (set_entity_allocation)(entity *ent, ent_allocation al) {
347 _set_entity_allocation(ent, al);
350 /* return the name of the visibility */
351 const char *get_allocation_name(ent_allocation all)
353 #define X(a) case a: return #a
355 X(allocation_automatic);
356 X(allocation_parameter);
357 X(allocation_dynamic);
358 X(allocation_static);
359 default: return "BAD VALUE";
366 (get_entity_visibility)(const entity *ent) {
367 return _get_entity_visibility(ent);
371 set_entity_visibility (entity *ent, visibility vis) {
372 assert(ent && ent->kind == k_entity);
373 if (vis != visibility_local)
374 assert((ent->allocation == allocation_static) ||
375 (ent->allocation == allocation_automatic));
376 /* @@@ Test that the owner type is not local, but how??
377 && get_class_visibility(get_entity_owner(ent)) != local));*/
378 ent->visibility = vis;
381 /* return the name of the visibility */
382 const char *get_visibility_name(visibility vis)
384 #define X(a) case a: return #a
387 X(visibility_external_visible);
388 X(visibility_external_allocated);
389 default: return "BAD VALUE";
395 (get_entity_variability)(const entity *ent) {
396 return _get_entity_variability(ent);
400 set_entity_variability (entity *ent, ent_variability var)
402 assert(ent && ent->kind == k_entity);
403 if (var == variability_part_constant)
404 assert(is_Class_type(ent->type) || is_Struct_type(ent->type));
406 if ((is_compound_type(ent->type)) &&
407 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
408 /* Allocate data structures for constant values */
409 ent->attr.cmpd_attr.values = NEW_ARR_F(ir_node *, 0);
410 ent->attr.cmpd_attr.val_paths = NEW_ARR_F(compound_graph_path *, 0);
412 if ((is_atomic_type(ent->type)) &&
413 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
414 /* Set default constant value. */
415 ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type));
418 if ((is_compound_type(ent->type)) &&
419 (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
420 /* Free data structures for constant values */
421 DEL_ARR_F(ent->attr.cmpd_attr.values); ent->attr.cmpd_attr.values = NULL;
422 DEL_ARR_F(ent->attr.cmpd_attr.val_paths); ent->attr.cmpd_attr.val_paths = NULL;
424 ent->variability = var;
427 /* return the name of the variability */
428 const char *get_variability_name(ent_variability var)
430 #define X(a) case a: return #a
432 X(variability_uninitialized);
433 X(variability_initialized);
434 X(variability_part_constant);
435 X(variability_constant);
436 default: return "BAD VALUE";
442 (get_entity_volatility)(const entity *ent) {
443 return _get_entity_volatility(ent);
447 (set_entity_volatility)(entity *ent, ent_volatility vol) {
448 _set_entity_volatility(ent, vol);
451 /* return the name of the volatility */
452 const char *get_volatility_name(ent_volatility var)
454 #define X(a) case a: return #a
456 X(volatility_non_volatile);
457 X(volatility_is_volatile);
458 default: return "BAD VALUE";
464 (get_entity_peculiarity)(const entity *ent) {
465 return _get_entity_peculiarity(ent);
469 (set_entity_peculiarity)(entity *ent, peculiarity pec) {
470 _set_entity_peculiarity(ent, pec);
473 /* return the name of the peculiarity */
474 const char *get_peculiarity_name(peculiarity var)
476 #define X(a) case a: return #a
478 X(peculiarity_description);
479 X(peculiarity_inherited);
480 X(peculiarity_existent);
481 default: return "BAD VALUE";
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, ent_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_type(tp) && 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 ARR_APP1 (ir_node *, ent->attr.cmpd_attr.values, val);
687 ARR_APP1 (compound_graph_path *, ent->attr.cmpd_attr.val_paths, path);
691 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
692 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
693 ent->attr.cmpd_attr.values[pos] = val;
694 ent->attr.cmpd_attr.val_paths[pos] = path;
698 get_compound_ent_n_values(entity *ent) {
699 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
700 return (ARR_LEN (ent->attr.cmpd_attr.values));
704 get_compound_ent_value(entity *ent, int pos) {
705 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
706 return ent->attr.cmpd_attr.values[pos];
709 compound_graph_path *
710 get_compound_ent_value_path(entity *ent, int pos) {
711 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
712 return ent->attr.cmpd_attr.val_paths[pos];
716 * Returns non-zero, if two compound_graph_pathes are equal
718 static int equal_paths(compound_graph_path *path1, int *visited_indicees, compound_graph_path *path2) {
720 int len1 = get_compound_graph_path_length(path1);
721 int len2 = get_compound_graph_path_length(path2);
723 if (len2 > len1) return 0;
725 for (i = 0; i < len1; i++) {
727 entity *node1 = get_compound_graph_path_node(path1, i);
728 entity *node2 = get_compound_graph_path_node(path2, i);
730 if (node1 != node2) return 0;
732 tp = get_entity_owner(node1);
733 if (is_Array_type(tp)) {
736 /* Compute the index of this node. */
737 assert(get_array_n_dimensions(tp) == 1 && "multidim not implemented");
739 low = get_array_lower_bound_int(tp, 0);
740 if (low + visited_indicees[i] < get_compound_graph_path_array_index(path2, i)) {
741 visited_indicees[i]++;
745 assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
751 /* Returns the position of a value with the given path.
752 * The path must contain array indicees for all array element entities. */
753 int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
754 int i, n_paths = get_compound_ent_n_values(ent);
755 int *visited_indicees = (int *)xcalloc(get_compound_graph_path_length(path), sizeof(int));
756 for (i = 0; i < n_paths; i ++) {
757 if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, path))
764 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
765 printf("Entity %s : ", get_entity_name(ent));
766 for (j = 0; j < get_compound_graph_path_length(path); ++j) {
767 entity *node = get_compound_graph_path_node(path, j);
768 printf("%s", get_entity_name(node));
769 if (is_Array_type(get_entity_owner(node)))
770 printf("[%d]", get_compound_graph_path_array_index(path, j));
772 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
776 assert(0 && "path not found");
780 /* Returns a constant value given the access path.
781 * The path must contain array indicees for all array element entities. */
782 ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path) {
783 return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
788 remove_compound_ent_value(entity *ent, entity *value_ent) {
790 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
791 for (i = 0; i < (ARR_LEN (ent->attr.cmpd_attr.val_paths)); i++) {
792 compound_graph_path *path = ent->attr.cmpd_attr.val_paths[i];
793 if (path->list[path->len-1].node == value_ent) {
794 for(; i < (ARR_LEN (ent->attr.cmpd_attr.val_paths))-1; i++) {
795 ent->attr.cmpd_attr.val_paths[i] = ent->attr.cmpd_attr.val_paths[i+1];
796 ent->attr.cmpd_attr.values[i] = ent->attr.cmpd_attr.values[i+1];
798 ARR_SETLEN(entity*, ent->attr.cmpd_attr.val_paths, ARR_LEN(ent->attr.cmpd_attr.val_paths) - 1);
799 ARR_SETLEN(ir_node*, ent->attr.cmpd_attr.values, ARR_LEN(ent->attr.cmpd_attr.values) - 1);
806 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
807 compound_graph_path *path;
808 ir_type *owner_tp = get_entity_owner(member);
809 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
810 path = new_compound_graph_path(get_entity_type(ent), 1);
811 path->list[0].node = member;
812 if (is_Array_type(owner_tp)) {
816 assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
817 max = get_array_lower_bound_int(owner_tp, 0) -1;
818 for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
819 int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
824 path->list[0].index = max + 1;
826 add_compound_ent_value_w_path(ent, val, path);
829 /* Copies the firm subgraph referenced by val to const_code_irg and adds
830 the node as constant initialization to ent.
831 The subgraph may not contain control flow operations.
833 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
834 ir_graph *rem = current_ir_graph;
836 assert(get_entity_variability(ent) != variability_uninitialized);
837 current_ir_graph = get_const_code_irg();
839 val = copy_const_value(val);
840 add_compound_ent_value(ent, val, member);
841 current_ir_graph = rem;
844 /* Copies the value i of the entity to current_block in current_ir_graph.
846 copy_compound_ent_value(entity *ent, int pos) {
847 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
848 return copy_const_value(ent->values[pos+1]);
852 get_compound_ent_value_member(entity *ent, int pos) {
853 compound_graph_path *path;
854 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
855 path = get_compound_ent_value_path(ent, pos);
857 return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
861 set_compound_ent_value(entity *ent, ir_node *val, entity *member, 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);
865 set_compound_graph_path_node(path, 0, member);
866 set_compound_ent_value_w_path(ent, val, path, pos);
870 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
872 ir_graph *rem = current_ir_graph;
873 ir_type *arrtp = get_entity_type(ent);
875 ir_type *elttp = get_array_element_type(arrtp);
877 assert(is_Array_type(arrtp));
878 assert(get_array_n_dimensions(arrtp) == 1);
879 /* One bound is sufficient, the number of constant fields makes the
881 assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
882 assert(get_entity_variability(ent) != variability_uninitialized);
883 current_ir_graph = get_const_code_irg();
885 for (i = 0; i < num_vals; i++) {
886 val = new_Const_type(values[i], elttp);
887 add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
888 set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
890 current_ir_graph = rem;
893 int get_compound_ent_value_offset_bits(entity *ent, int pos) {
894 compound_graph_path *path;
898 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
900 path = get_compound_ent_value_path(ent, pos);
901 path_len = get_compound_graph_path_length(path);
903 for (i = 0; i < path_len; ++i) {
904 entity *node = get_compound_graph_path_node(path, i);
905 ir_type *node_tp = get_entity_type(node);
906 ir_type *owner_tp = get_entity_owner(node);
907 if (is_Array_type(owner_tp)) {
908 int size = get_type_size_bits(node_tp);
909 int align = get_type_alignment_bits(node_tp);
913 assert(size % align == 0);
914 /* ansonsten aufrunden */
916 offset += size * get_compound_graph_path_array_index(path, i);
918 offset += get_entity_offset_bits(node);
924 int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
925 int offset = get_compound_ent_value_offset_bits(ent, pos);
926 assert(offset % 8 == 0);
931 static void init_index(ir_type *arr) {
935 assert(get_array_n_dimensions(arr) == 1);
937 if (has_array_lower_bound(arr, dim))
938 init = get_array_lower_bound_int(arr, 0) -1;
940 init = get_array_upper_bound_int(arr, 0) +1;
942 set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
946 static int get_next_index(entity *elem_ent) {
947 ir_type *arr = get_entity_owner(elem_ent);
951 assert(get_array_n_dimensions(arr) == 1);
953 if (has_array_lower_bound(arr, dim)) {
954 next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
955 if (has_array_upper_bound(arr, dim)) {
956 int upper = get_array_upper_bound_int(arr, dim);
957 if (next == upper) next = get_array_lower_bound_int(arr, dim);
960 next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
961 if (has_array_lower_bound(arr, dim)) {
962 int upper = get_array_upper_bound_int(arr, dim);
963 if (next == upper) next = get_array_upper_bound_int(arr, dim);
967 set_entity_link(elem_ent, INT_TO_PTR(next));
971 /* Compute the array indices in compound graph paths of initialized entities.
973 * All arrays must have fixed lower and upper bounds. One array can
974 * have an open bound. If there are several open bounds, we do
975 * nothing. There must be initializer elements for all array
976 * elements. Uses the link field in the array element entities. The
977 * array bounds must be representable as ints.
979 * (If the bounds are not representable as ints we have to represent
980 * the indices as firm nodes. But still we must be able to
981 * evaluate the index against the upper bound.)
983 void compute_compound_ent_array_indicees(entity *ent) {
984 ir_type *tp = get_entity_type(ent);
986 entity *unknown_bound_entity = NULL;
988 if (!is_compound_type(tp) ||
989 (ent->variability == variability_uninitialized)) return ;
991 n_vals = get_compound_ent_n_values(ent);
992 if (n_vals == 0) return;
994 /* We can not compute the indexes if there is more than one array
995 with an unknown bound. For this remember the first entity that
996 represents such an array. It could be ent. */
997 if (is_Array_type(tp)) {
1000 assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
1001 if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
1002 unknown_bound_entity = ent;
1005 /* Initialize the entity links to lower bound -1 and test all path elements
1006 for known bounds. */
1007 for (i = 0; i < n_vals; ++i) {
1008 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1009 int j, path_len = get_compound_graph_path_length(path);
1010 for (j = 0; j < path_len; ++j) {
1011 entity *node = get_compound_graph_path_node(path, j);
1012 ir_type *elem_tp = get_entity_type(node);
1014 if (is_Array_type(elem_tp)) {
1016 assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
1017 if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
1018 if (!unknown_bound_entity) unknown_bound_entity = node;
1019 if (node != unknown_bound_entity) return;
1022 init_index(elem_tp);
1027 /* Finally compute the indexes ... */
1028 for (i = 0; i < n_vals; ++i) {
1029 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1030 int j, path_len = get_compound_graph_path_length(path);
1031 for (j = 0; j < path_len; ++j) {
1032 entity *node = get_compound_graph_path_node(path, j);
1033 ir_type *owner_tp = get_entity_owner(node);
1034 if (is_Array_type(owner_tp))
1035 set_compound_graph_path_array_index (path, j, get_next_index(node));
1040 /** resize: double the allocated buffer */
1041 static int *resize (int *buf, int *size) {
1042 int new_size = *size * 2;
1043 int *new_buf = xcalloc(new_size, sizeof(new_buf[0]));
1044 memcpy(new_buf, buf, *size);
1050 /* We sort the elements by placing them at their bit offset in an
1051 array where each entry represents one bit called permutation. In
1052 fact, we do not place the values themselves, as we would have to
1053 copy two things, the value and the path. We only remember the
1054 position in the old order. Each value should have a distinct
1055 position in the permutation.
1057 A second iteration now permutes the actual elements into two
1059 void sort_compound_ent_values(entity *ent) {
1067 ir_node **my_values;
1068 compound_graph_path **my_paths;
1070 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
1072 tp = get_entity_type(ent);
1073 n_vals = get_compound_ent_n_values(ent);
1074 tp_size = get_type_size_bits(tp);
1076 if (!is_compound_type(tp) ||
1077 (ent->variability == variability_uninitialized) ||
1078 (get_type_state(tp) != layout_fixed) ||
1079 (n_vals == 0) ) return;
1081 /* estimated upper bound for size. Better: use flexible array ... */
1082 size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
1083 permutation = xcalloc(size, sizeof(permutation[0]));
1085 for (i = 0; i < n_vals; ++i) {
1086 int pos = get_compound_ent_value_offset_bits(ent, i);
1087 while (pos >= size) {
1088 permutation = resize(permutation, &size);
1091 assert(permutation[pos] == 0 && "two values with the same offset");
1092 permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
1093 So inc all entries by one. */
1094 //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
1098 my_values = NEW_ARR_F(ir_node *, n_vals);
1099 my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
1100 for (i = 0; i < size; ++i) {
1101 int pos = permutation[i];
1103 //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next);
1104 assert(next < n_vals);
1105 pos--; /* We increased the pos by one */
1106 my_values[next] = get_compound_ent_value (ent, pos);
1107 my_paths [next] = get_compound_ent_value_path(ent, pos);
1113 DEL_ARR_F(ent->attr.cmpd_attr.values);
1114 ent->attr.cmpd_attr.values = my_values;
1115 DEL_ARR_F(ent->attr.cmpd_attr.val_paths);
1116 ent->attr.cmpd_attr.val_paths = my_paths;
1120 (get_entity_offset_bytes)(const entity *ent) {
1121 return _get_entity_offset_bytes(ent);
1125 (get_entity_offset_bits)(const entity *ent) {
1126 return _get_entity_offset_bits(ent);
1130 (set_entity_offset_bytes)(entity *ent, int offset) {
1131 _set_entity_offset_bytes(ent, offset);
1135 (set_entity_offset_bits)(entity *ent, int offset) {
1136 _set_entity_offset_bits(ent, offset);
1140 add_entity_overwrites(entity *ent, entity *overwritten) {
1141 assert(ent && is_Class_type(get_entity_owner(ent)));
1142 ARR_APP1(entity *, ent->overwrites, overwritten);
1143 ARR_APP1(entity *, overwritten->overwrittenby, ent);
1147 get_entity_n_overwrites(entity *ent) {
1148 assert(ent && is_Class_type(get_entity_owner(ent)));
1149 return (ARR_LEN(ent->overwrites));
1153 get_entity_overwrites_index(entity *ent, entity *overwritten) {
1155 assert(ent && is_Class_type(get_entity_owner(ent)));
1156 for (i = 0; i < get_entity_n_overwrites(ent); i++)
1157 if (get_entity_overwrites(ent, i) == overwritten)
1163 get_entity_overwrites (entity *ent, int pos) {
1164 assert(ent && is_Class_type(get_entity_owner(ent)));
1165 assert(pos < get_entity_n_overwrites(ent));
1166 return ent->overwrites[pos];
1170 set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
1171 assert(ent && is_Class_type(get_entity_owner(ent)));
1172 assert(pos < get_entity_n_overwrites(ent));
1173 ent->overwrites[pos] = overwritten;
1177 remove_entity_overwrites(entity *ent, entity *overwritten) {
1179 assert(ent && is_Class_type(get_entity_owner(ent)));
1180 for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1181 if (ent->overwrites[i] == overwritten) {
1182 for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1183 ent->overwrites[i] = ent->overwrites[i+1];
1184 ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1190 add_entity_overwrittenby (entity *ent, entity *overwrites) {
1191 assert(ent && is_Class_type(get_entity_owner(ent)));
1192 add_entity_overwrites(overwrites, ent);
1196 get_entity_n_overwrittenby (entity *ent) {
1197 assert(ent && is_Class_type(get_entity_owner(ent)));
1198 return (ARR_LEN (ent->overwrittenby));
1202 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1204 assert(ent && is_Class_type(get_entity_owner(ent)));
1205 for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1206 if (get_entity_overwrittenby(ent, i) == overwrites)
1212 get_entity_overwrittenby (entity *ent, int pos) {
1213 assert(ent && is_Class_type(get_entity_owner(ent)));
1214 assert(pos < get_entity_n_overwrittenby(ent));
1215 return ent->overwrittenby[pos];
1219 set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
1220 assert(ent && is_Class_type(get_entity_owner(ent)));
1221 assert(pos < get_entity_n_overwrittenby(ent));
1222 ent->overwrittenby[pos] = overwrites;
1225 void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1227 assert(ent && is_Class_type(get_entity_owner(ent)));
1228 for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1229 if (ent->overwrittenby[i] == overwrites) {
1230 for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1231 ent->overwrittenby[i] = ent->overwrittenby[i+1];
1232 ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1237 /* A link to store intermediate information */
1239 (get_entity_link)(const entity *ent) {
1240 return _get_entity_link(ent);
1244 (set_entity_link)(entity *ent, void *l) {
1245 _set_entity_link(ent, l);
1249 (get_entity_irg)(const entity *ent) {
1250 return _get_entity_irg(ent);
1254 set_entity_irg(entity *ent, ir_graph *irg) {
1255 assert(ent && is_method_entity(ent));
1256 /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1257 * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1258 * aber erhalten bleiben soll? Wandle die Entitaet in description oder
1261 assert((irg && ent->peculiarity == peculiarity_existent) ||
1262 (!irg && (ent->peculiarity == peculiarity_existent)
1263 && (ent -> visibility == visibility_external_allocated)) ||
1264 (!irg && ent->peculiarity == peculiarity_description) ||
1265 (!irg && ent->peculiarity == peculiarity_inherited));
1266 ent->attr.mtd_attr.irg = irg;
1269 unsigned get_entity_vtable_number(entity *ent) {
1270 assert(ent && is_method_entity(ent));
1271 return ent->attr.mtd_attr.vtable_number;
1274 void set_entity_vtable_number(entity *ent, unsigned vtable_number) {
1275 assert(ent && is_method_entity(ent));
1276 ent->attr.mtd_attr.vtable_number = vtable_number;
1280 (is_entity)(const void *thing) {
1281 return _is_entity(thing);
1284 int is_atomic_entity(entity *ent) {
1285 ir_type *t = get_entity_type(ent);
1286 assert(ent && ent->kind == k_entity);
1287 return (is_Primitive_type(t) || is_Pointer_type(t) ||
1288 is_Enumeration_type(t) || is_Method_type(t));
1291 int is_compound_entity(entity *ent) {
1292 ir_type *t = get_entity_type(ent);
1293 assert(ent && ent->kind == k_entity);
1294 return (is_Class_type(t) || is_Struct_type(t) ||
1295 is_Array_type(t) || is_Union_type(t));
1298 int is_method_entity(entity *ent) {
1299 ir_type *t = get_entity_type(ent);
1300 assert(ent && ent->kind == k_entity);
1301 return (is_Method_type(t));
1305 * @todo not implemented!!! */
1306 int equal_entity(entity *ent1, entity *ent2) {
1307 fprintf(stderr, " calling unimplemented equal entity!!! \n");
1312 unsigned long (get_entity_visited)(entity *ent) {
1313 return _get_entity_visited(ent);
1316 void (set_entity_visited)(entity *ent, unsigned long num) {
1317 _set_entity_visited(ent, num);
1320 /* Sets visited field in entity to entity_visited. */
1321 void (mark_entity_visited)(entity *ent) {
1322 _mark_entity_visited(ent);
1325 int (entity_visited)(entity *ent) {
1326 return _entity_visited(ent);
1329 int (entity_not_visited)(entity *ent) {
1330 return _entity_not_visited(ent);
1333 /* Returns the mask of the additional entity properties. */
1334 unsigned get_entity_additional_properties(entity *ent) {
1337 assert(is_method_entity(ent));
1339 /* first check, if the graph has additional properties */
1340 irg = get_entity_irg(ent);
1343 return get_irg_additional_properties(irg);
1345 if (ent->attr.mtd_attr.irg_add_properties & mtp_property_inherited)
1346 return get_method_additional_properties(get_entity_type(ent));
1348 return ent->attr.mtd_attr.irg_add_properties;
1351 /* Sets the mask of the additional graph properties. */
1352 void set_entity_additional_properties(entity *ent, unsigned property_mask)
1356 assert(is_method_entity(ent));
1358 /* first check, if the graph exists */
1359 irg = get_entity_irg(ent);
1361 set_irg_additional_properties(irg, property_mask);
1363 /* do not allow to set the mtp_property_inherited flag or
1364 * the automatic inheritance of flags will not work */
1365 ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited;
1369 /* Sets one additional graph property. */
1370 void set_entity_additional_property(entity *ent, mtp_additional_property flag)
1374 assert(is_method_entity(ent));
1376 /* first check, if the graph exists */
1377 irg = get_entity_irg(ent);
1379 set_irg_additional_property(irg, flag);
1381 unsigned mask = ent->attr.mtd_attr.irg_add_properties;
1383 if (mask & mtp_property_inherited)
1384 mask = get_method_additional_properties(get_entity_type(ent));
1386 /* do not allow to set the mtp_property_inherited flag or
1387 * the automatic inheritance of flags will not work */
1388 ent->attr.mtd_attr.irg_add_properties = mask | (flag & ~mtp_property_inherited);
1392 /* Initialize entity module. */
1393 void firm_init_entity(void)
1395 symconst_symbol sym;
1397 assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
1398 assert(!unknown_entity && "Call firm_init_entity() only once!");
1400 unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
1401 set_entity_visibility(unknown_entity, visibility_external_allocated);
1402 set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
1404 current_ir_graph = get_const_code_irg();
1405 sym.entity_p = unknown_entity;
1406 unknown_entity->value = new_SymConst(sym, symconst_addr_ent);