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 /* Get the entity's stickyness */
475 (get_entity_stickyness)(const entity *ent) {
476 return _get_entity_stickyness(ent);
479 /* Set the entity's stickyness */
481 (set_entity_stickyness)(entity *ent, ent_stickyness stickyness) {
482 _set_entity_stickyness(ent, stickyness);
485 /* Set has no effect for existent entities of type method. */
487 get_atomic_ent_value(entity *ent)
489 assert(ent && is_atomic_entity(ent));
490 assert(ent->variability != variability_uninitialized);
491 return skip_Id (ent->value);
495 set_atomic_ent_value(entity *ent, ir_node *val) {
496 assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
497 if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
502 /* Returns true if the the node is representable as code on
504 int is_irn_const_expression(ir_node *n) {
507 /* we are in danger iff an exception will arise. TODO: be more precisely,
508 * for instance Div. will NOT rise if divisor != 0
510 if (is_binop(n) && !is_fragile_op(n))
511 return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
514 switch(get_irn_opcode(n)) {
521 return is_irn_const_expression(get_irn_n(n, 0));
529 * Copies a firm subgraph that complies to the restrictions for
530 * constant expressions to current_block in current_ir_graph.
532 ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
536 /* @@@ GL I think we should implement this using the routines from irgopt for
537 dead node elimination/inlineing. */
540 switch (get_irn_opcode(n)) {
542 nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
545 nn = new_d_SymConst_type(dbg, get_SymConst_symbol(n), get_SymConst_kind(n),
546 get_SymConst_value_type(n));
549 nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)),
550 copy_const_value(dbg, get_Add_right(n)), m); break;
552 nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)),
553 copy_const_value(dbg, get_Sub_right(n)), m); break;
555 nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)),
556 copy_const_value(dbg, get_Mul_right(n)), m); break;
558 nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)),
559 copy_const_value(dbg, get_And_right(n)), m); break;
561 nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)),
562 copy_const_value(dbg, get_Or_right(n)), m); break;
564 nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)),
565 copy_const_value(dbg, get_Eor_right(n)), m); break;
567 nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break;
569 nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break;
571 nn = new_d_Unknown(m); break;
574 assert(0 && "opcode invalid or not implemented");
581 /* Creates a new compound graph path. */
582 compound_graph_path *
583 new_compound_graph_path(ir_type *tp, int length) {
584 compound_graph_path *res;
586 assert(is_type(tp) && is_compound_type(tp));
589 res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->list[0]));
590 memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->list[0]));
591 res->kind = k_ir_compound_graph_path;
598 /* Frees an graph path object */
599 void free_compound_graph_path (compound_graph_path *gr) {
600 assert(gr && is_compound_graph_path(gr));
605 /* Returns non-zero if an object is a compound graph path */
606 int is_compound_graph_path(void *thing) {
607 return (get_kind(thing) == k_ir_compound_graph_path);
610 /* Checks whether the path up to pos is correct. If the path contains a NULL,
611 * assumes the path is not complete and returns 'true'. */
612 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
615 ir_type *owner = gr->tp;
617 for (i = 0; i <= pos; i++) {
618 node = get_compound_graph_path_node(gr, i);
620 /* Path not yet complete. */
622 if (get_entity_owner(node) != owner)
624 owner = get_entity_type(node);
626 if (pos == get_compound_graph_path_length(gr))
627 if (!is_atomic_type(owner))
632 /* Returns the length of a graph path */
633 int get_compound_graph_path_length(compound_graph_path *gr) {
634 assert(gr && is_compound_graph_path(gr));
639 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
640 assert(gr && is_compound_graph_path(gr));
641 assert(pos >= 0 && pos < gr->len);
642 return gr->list[pos].node;
646 set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
647 assert(gr && is_compound_graph_path(gr));
648 assert(pos >= 0 && pos < gr->len);
649 assert(is_entity(node));
650 gr->list[pos].node = node;
651 assert(is_proper_compound_graph_path(gr, pos));
655 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
656 assert(gr && is_compound_graph_path(gr));
657 assert(pos >= 0 && pos < gr->len);
658 return gr->list[pos].index;
662 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
663 assert(gr && is_compound_graph_path(gr));
664 assert(pos >= 0 && pos < gr->len);
665 gr->list[pos].index = index;
668 /* A value of a compound entity is a pair of value and the corresponding path to a member of
671 add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
672 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
673 ARR_APP1 (ir_node *, ent->attr.cmpd_attr.values, val);
674 ARR_APP1 (compound_graph_path *, ent->attr.cmpd_attr.val_paths, path);
678 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
679 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
680 ent->attr.cmpd_attr.values[pos] = val;
681 ent->attr.cmpd_attr.val_paths[pos] = path;
685 get_compound_ent_n_values(entity *ent) {
686 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
687 return (ARR_LEN (ent->attr.cmpd_attr.values));
691 get_compound_ent_value(entity *ent, int pos) {
692 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
693 return ent->attr.cmpd_attr.values[pos];
696 compound_graph_path *
697 get_compound_ent_value_path(entity *ent, int pos) {
698 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
699 return ent->attr.cmpd_attr.val_paths[pos];
703 * Returns non-zero, if two compound_graph_pathes are equal
705 static int equal_paths(compound_graph_path *path1, int *visited_indicees, compound_graph_path *path2) {
707 int len1 = get_compound_graph_path_length(path1);
708 int len2 = get_compound_graph_path_length(path2);
710 if (len2 > len1) return 0;
712 for (i = 0; i < len1; i++) {
714 entity *node1 = get_compound_graph_path_node(path1, i);
715 entity *node2 = get_compound_graph_path_node(path2, i);
717 if (node1 != node2) return 0;
719 tp = get_entity_owner(node1);
720 if (is_Array_type(tp)) {
723 /* Compute the index of this node. */
724 assert(get_array_n_dimensions(tp) == 1 && "multidim not implemented");
726 low = get_array_lower_bound_int(tp, 0);
727 if (low + visited_indicees[i] < get_compound_graph_path_array_index(path2, i)) {
728 visited_indicees[i]++;
732 assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
738 /* Returns the position of a value with the given path.
739 * The path must contain array indicees for all array element entities. */
740 int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
741 int i, n_paths = get_compound_ent_n_values(ent);
742 int *visited_indicees = (int *)xcalloc(get_compound_graph_path_length(path), sizeof(int));
743 for (i = 0; i < n_paths; i ++) {
744 if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, path))
751 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
752 printf("Entity %s : ", get_entity_name(ent));
753 for (j = 0; j < get_compound_graph_path_length(path); ++j) {
754 entity *node = get_compound_graph_path_node(path, j);
755 printf("%s", get_entity_name(node));
756 if (is_Array_type(get_entity_owner(node)))
757 printf("[%d]", get_compound_graph_path_array_index(path, j));
759 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
763 assert(0 && "path not found");
767 /* Returns a constant value given the access path.
768 * The path must contain array indicees for all array element entities. */
769 ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path) {
770 return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
775 remove_compound_ent_value(entity *ent, entity *value_ent) {
777 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
778 for (i = 0; i < (ARR_LEN (ent->attr.cmpd_attr.val_paths)); i++) {
779 compound_graph_path *path = ent->attr.cmpd_attr.val_paths[i];
780 if (path->list[path->len-1].node == value_ent) {
781 for(; i < (ARR_LEN (ent->attr.cmpd_attr.val_paths))-1; i++) {
782 ent->attr.cmpd_attr.val_paths[i] = ent->attr.cmpd_attr.val_paths[i+1];
783 ent->attr.cmpd_attr.values[i] = ent->attr.cmpd_attr.values[i+1];
785 ARR_SETLEN(entity*, ent->attr.cmpd_attr.val_paths, ARR_LEN(ent->attr.cmpd_attr.val_paths) - 1);
786 ARR_SETLEN(ir_node*, ent->attr.cmpd_attr.values, ARR_LEN(ent->attr.cmpd_attr.values) - 1);
793 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
794 compound_graph_path *path;
795 ir_type *owner_tp = get_entity_owner(member);
796 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
797 path = new_compound_graph_path(get_entity_type(ent), 1);
798 path->list[0].node = member;
799 if (is_Array_type(owner_tp)) {
803 assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
804 max = get_array_lower_bound_int(owner_tp, 0) -1;
805 for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
806 int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
811 path->list[0].index = max + 1;
813 add_compound_ent_value_w_path(ent, val, path);
816 /* Copies the firm subgraph referenced by val to const_code_irg and adds
817 the node as constant initialization to ent.
818 The subgraph may not contain control flow operations.
820 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
821 ir_graph *rem = current_ir_graph;
823 assert(get_entity_variability(ent) != variability_uninitialized);
824 current_ir_graph = get_const_code_irg();
826 val = copy_const_value(val);
827 add_compound_ent_value(ent, val, member);
828 current_ir_graph = rem;
831 /* Copies the value i of the entity to current_block in current_ir_graph.
833 copy_compound_ent_value(entity *ent, int pos) {
834 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
835 return copy_const_value(ent->values[pos+1]);
839 get_compound_ent_value_member(entity *ent, int pos) {
840 compound_graph_path *path;
841 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
842 path = get_compound_ent_value_path(ent, pos);
844 return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
848 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
849 compound_graph_path *path;
850 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
851 path = get_compound_ent_value_path(ent, pos);
852 set_compound_graph_path_node(path, 0, member);
853 set_compound_ent_value_w_path(ent, val, path, pos);
857 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
859 ir_graph *rem = current_ir_graph;
860 ir_type *arrtp = get_entity_type(ent);
862 ir_type *elttp = get_array_element_type(arrtp);
864 assert(is_Array_type(arrtp));
865 assert(get_array_n_dimensions(arrtp) == 1);
866 /* One bound is sufficient, the number of constant fields makes the
868 assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
869 assert(get_entity_variability(ent) != variability_uninitialized);
870 current_ir_graph = get_const_code_irg();
872 for (i = 0; i < num_vals; i++) {
873 val = new_Const_type(values[i], elttp);
874 add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
875 set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
877 current_ir_graph = rem;
880 int get_compound_ent_value_offset_bits(entity *ent, int pos) {
881 compound_graph_path *path;
885 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
887 path = get_compound_ent_value_path(ent, pos);
888 path_len = get_compound_graph_path_length(path);
890 for (i = 0; i < path_len; ++i) {
891 entity *node = get_compound_graph_path_node(path, i);
892 ir_type *node_tp = get_entity_type(node);
893 ir_type *owner_tp = get_entity_owner(node);
894 if (is_Array_type(owner_tp)) {
895 int size = get_type_size_bits(node_tp);
896 int align = get_type_alignment_bits(node_tp);
900 assert(size % align == 0);
901 /* ansonsten aufrunden */
903 offset += size * get_compound_graph_path_array_index(path, i);
905 offset += get_entity_offset_bits(node);
911 int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
912 int offset = get_compound_ent_value_offset_bits(ent, pos);
913 assert(offset % 8 == 0);
918 static void init_index(ir_type *arr) {
922 assert(get_array_n_dimensions(arr) == 1);
924 if (has_array_lower_bound(arr, dim))
925 init = get_array_lower_bound_int(arr, 0) -1;
927 init = get_array_upper_bound_int(arr, 0) +1;
929 set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
933 static int get_next_index(entity *elem_ent) {
934 ir_type *arr = get_entity_owner(elem_ent);
938 assert(get_array_n_dimensions(arr) == 1);
940 if (has_array_lower_bound(arr, dim)) {
941 next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
942 if (has_array_upper_bound(arr, dim)) {
943 int upper = get_array_upper_bound_int(arr, dim);
944 if (next == upper) next = get_array_lower_bound_int(arr, dim);
947 next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
948 if (has_array_lower_bound(arr, dim)) {
949 int upper = get_array_upper_bound_int(arr, dim);
950 if (next == upper) next = get_array_upper_bound_int(arr, dim);
954 set_entity_link(elem_ent, INT_TO_PTR(next));
958 /* Compute the array indices in compound graph paths of initialized entities.
960 * All arrays must have fixed lower and upper bounds. One array can
961 * have an open bound. If there are several open bounds, we do
962 * nothing. There must be initializer elements for all array
963 * elements. Uses the link field in the array element entities. The
964 * array bounds must be representable as ints.
966 * (If the bounds are not representable as ints we have to represent
967 * the indices as firm nodes. But still we must be able to
968 * evaluate the index against the upper bound.)
970 void compute_compound_ent_array_indicees(entity *ent) {
971 ir_type *tp = get_entity_type(ent);
973 entity *unknown_bound_entity = NULL;
975 if (!is_compound_type(tp) ||
976 (ent->variability == variability_uninitialized)) return ;
978 n_vals = get_compound_ent_n_values(ent);
979 if (n_vals == 0) return;
981 /* We can not compute the indexes if there is more than one array
982 with an unknown bound. For this remember the first entity that
983 represents such an array. It could be ent. */
984 if (is_Array_type(tp)) {
987 assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
988 if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
989 unknown_bound_entity = ent;
992 /* Initialize the entity links to lower bound -1 and test all path elements
994 for (i = 0; i < n_vals; ++i) {
995 compound_graph_path *path = get_compound_ent_value_path(ent, i);
996 int j, path_len = get_compound_graph_path_length(path);
997 for (j = 0; j < path_len; ++j) {
998 entity *node = get_compound_graph_path_node(path, j);
999 ir_type *elem_tp = get_entity_type(node);
1001 if (is_Array_type(elem_tp)) {
1003 assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
1004 if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
1005 if (!unknown_bound_entity) unknown_bound_entity = node;
1006 if (node != unknown_bound_entity) return;
1009 init_index(elem_tp);
1014 /* Finally compute the indexes ... */
1015 for (i = 0; i < n_vals; ++i) {
1016 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1017 int j, path_len = get_compound_graph_path_length(path);
1018 for (j = 0; j < path_len; ++j) {
1019 entity *node = get_compound_graph_path_node(path, j);
1020 ir_type *owner_tp = get_entity_owner(node);
1021 if (is_Array_type(owner_tp))
1022 set_compound_graph_path_array_index (path, j, get_next_index(node));
1027 /** resize: double the allocated buffer */
1028 static int *resize (int *buf, int *size) {
1029 int new_size = *size * 2;
1030 int *new_buf = xcalloc(new_size, sizeof(new_buf[0]));
1031 memcpy(new_buf, buf, *size);
1037 /* We sort the elements by placing them at their bit offset in an
1038 array where each entry represents one bit called permutation. In
1039 fact, we do not place the values themselves, as we would have to
1040 copy two things, the value and the path. We only remember the
1041 position in the old order. Each value should have a distinct
1042 position in the permutation.
1044 A second iteration now permutes the actual elements into two
1046 void sort_compound_ent_values(entity *ent) {
1054 ir_node **my_values;
1055 compound_graph_path **my_paths;
1057 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
1059 tp = get_entity_type(ent);
1060 n_vals = get_compound_ent_n_values(ent);
1061 tp_size = get_type_size_bits(tp);
1063 if (!is_compound_type(tp) ||
1064 (ent->variability == variability_uninitialized) ||
1065 (get_type_state(tp) != layout_fixed) ||
1066 (n_vals == 0) ) return;
1068 /* estimated upper bound for size. Better: use flexible array ... */
1069 size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
1070 permutation = xcalloc(size, sizeof(permutation[0]));
1072 for (i = 0; i < n_vals; ++i) {
1073 int pos = get_compound_ent_value_offset_bits(ent, i);
1074 while (pos >= size) {
1075 permutation = resize(permutation, &size);
1078 assert(permutation[pos] == 0 && "two values with the same offset");
1079 permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
1080 So inc all entries by one. */
1081 //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
1085 my_values = NEW_ARR_F(ir_node *, n_vals);
1086 my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
1087 for (i = 0; i < size; ++i) {
1088 int pos = permutation[i];
1090 //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next);
1091 assert(next < n_vals);
1092 pos--; /* We increased the pos by one */
1093 my_values[next] = get_compound_ent_value (ent, pos);
1094 my_paths [next] = get_compound_ent_value_path(ent, pos);
1100 DEL_ARR_F(ent->attr.cmpd_attr.values);
1101 ent->attr.cmpd_attr.values = my_values;
1102 DEL_ARR_F(ent->attr.cmpd_attr.val_paths);
1103 ent->attr.cmpd_attr.val_paths = my_paths;
1107 (get_entity_offset_bytes)(const entity *ent) {
1108 return _get_entity_offset_bytes(ent);
1112 (get_entity_offset_bits)(const entity *ent) {
1113 return _get_entity_offset_bits(ent);
1117 (set_entity_offset_bytes)(entity *ent, int offset) {
1118 _set_entity_offset_bytes(ent, offset);
1122 (set_entity_offset_bits)(entity *ent, int offset) {
1123 _set_entity_offset_bits(ent, offset);
1127 add_entity_overwrites(entity *ent, entity *overwritten) {
1128 assert(ent && is_Class_type(get_entity_owner(ent)));
1129 ARR_APP1(entity *, ent->overwrites, overwritten);
1130 ARR_APP1(entity *, overwritten->overwrittenby, ent);
1134 get_entity_n_overwrites(entity *ent) {
1135 assert(ent && is_Class_type(get_entity_owner(ent)));
1136 return (ARR_LEN(ent->overwrites));
1140 get_entity_overwrites_index(entity *ent, entity *overwritten) {
1142 assert(ent && is_Class_type(get_entity_owner(ent)));
1143 for (i = 0; i < get_entity_n_overwrites(ent); i++)
1144 if (get_entity_overwrites(ent, i) == overwritten)
1150 get_entity_overwrites (entity *ent, int pos) {
1151 assert(ent && is_Class_type(get_entity_owner(ent)));
1152 assert(pos < get_entity_n_overwrites(ent));
1153 return ent->overwrites[pos];
1157 set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
1158 assert(ent && is_Class_type(get_entity_owner(ent)));
1159 assert(pos < get_entity_n_overwrites(ent));
1160 ent->overwrites[pos] = overwritten;
1164 remove_entity_overwrites(entity *ent, entity *overwritten) {
1166 assert(ent && is_Class_type(get_entity_owner(ent)));
1167 for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1168 if (ent->overwrites[i] == overwritten) {
1169 for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1170 ent->overwrites[i] = ent->overwrites[i+1];
1171 ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1177 add_entity_overwrittenby (entity *ent, entity *overwrites) {
1178 assert(ent && is_Class_type(get_entity_owner(ent)));
1179 add_entity_overwrites(overwrites, ent);
1183 get_entity_n_overwrittenby (entity *ent) {
1184 assert(ent && is_Class_type(get_entity_owner(ent)));
1185 return (ARR_LEN (ent->overwrittenby));
1189 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1191 assert(ent && is_Class_type(get_entity_owner(ent)));
1192 for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1193 if (get_entity_overwrittenby(ent, i) == overwrites)
1199 get_entity_overwrittenby (entity *ent, int pos) {
1200 assert(ent && is_Class_type(get_entity_owner(ent)));
1201 assert(pos < get_entity_n_overwrittenby(ent));
1202 return ent->overwrittenby[pos];
1206 set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
1207 assert(ent && is_Class_type(get_entity_owner(ent)));
1208 assert(pos < get_entity_n_overwrittenby(ent));
1209 ent->overwrittenby[pos] = overwrites;
1212 void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1214 assert(ent && is_Class_type(get_entity_owner(ent)));
1215 for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1216 if (ent->overwrittenby[i] == overwrites) {
1217 for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1218 ent->overwrittenby[i] = ent->overwrittenby[i+1];
1219 ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1224 /* A link to store intermediate information */
1226 (get_entity_link)(const entity *ent) {
1227 return _get_entity_link(ent);
1231 (set_entity_link)(entity *ent, void *l) {
1232 _set_entity_link(ent, l);
1236 (get_entity_irg)(const entity *ent) {
1237 return _get_entity_irg(ent);
1241 set_entity_irg(entity *ent, ir_graph *irg) {
1242 assert(ent && is_method_entity(ent));
1243 /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1244 * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1245 * aber erhalten bleiben soll? Wandle die Entitaet in description oder
1248 assert((irg && ent->peculiarity == peculiarity_existent) ||
1249 (!irg && (ent->peculiarity == peculiarity_existent)
1250 && (ent -> visibility == visibility_external_allocated)) ||
1251 (!irg && ent->peculiarity == peculiarity_description) ||
1252 (!irg && ent->peculiarity == peculiarity_inherited));
1253 ent->attr.mtd_attr.irg = irg;
1256 unsigned get_entity_vtable_number(entity *ent) {
1257 assert(ent && is_method_entity(ent));
1258 return ent->attr.mtd_attr.vtable_number;
1261 void set_entity_vtable_number(entity *ent, unsigned vtable_number) {
1262 assert(ent && is_method_entity(ent));
1263 ent->attr.mtd_attr.vtable_number = vtable_number;
1267 (is_entity)(const void *thing) {
1268 return _is_entity(thing);
1271 int is_atomic_entity(entity *ent) {
1272 ir_type *t = get_entity_type(ent);
1273 assert(ent && ent->kind == k_entity);
1274 return (is_Primitive_type(t) || is_Pointer_type(t) ||
1275 is_Enumeration_type(t) || is_Method_type(t));
1278 int is_compound_entity(entity *ent) {
1279 ir_type *t = get_entity_type(ent);
1280 assert(ent && ent->kind == k_entity);
1281 return (is_Class_type(t) || is_Struct_type(t) ||
1282 is_Array_type(t) || is_Union_type(t));
1285 int is_method_entity(entity *ent) {
1286 ir_type *t = get_entity_type(ent);
1287 assert(ent && ent->kind == k_entity);
1288 return (is_Method_type(t));
1292 * @todo not implemented!!! */
1293 int equal_entity(entity *ent1, entity *ent2) {
1294 fprintf(stderr, " calling unimplemented equal entity!!! \n");
1299 unsigned long (get_entity_visited)(entity *ent) {
1300 return _get_entity_visited(ent);
1303 void (set_entity_visited)(entity *ent, unsigned long num) {
1304 _set_entity_visited(ent, num);
1307 /* Sets visited field in entity to entity_visited. */
1308 void (mark_entity_visited)(entity *ent) {
1309 _mark_entity_visited(ent);
1312 int (entity_visited)(entity *ent) {
1313 return _entity_visited(ent);
1316 int (entity_not_visited)(entity *ent) {
1317 return _entity_not_visited(ent);
1320 /* Returns the mask of the additional entity properties. */
1321 unsigned get_entity_additional_properties(entity *ent) {
1324 assert(is_method_entity(ent));
1326 /* first check, if the graph has additional properties */
1327 irg = get_entity_irg(ent);
1330 return get_irg_additional_properties(irg);
1332 if (ent->attr.mtd_attr.irg_add_properties & mtp_property_inherited)
1333 return get_method_additional_properties(get_entity_type(ent));
1335 return ent->attr.mtd_attr.irg_add_properties;
1338 /* Sets the mask of the additional graph properties. */
1339 void set_entity_additional_properties(entity *ent, unsigned property_mask)
1343 assert(is_method_entity(ent));
1345 /* first check, if the graph exists */
1346 irg = get_entity_irg(ent);
1348 set_irg_additional_properties(irg, property_mask);
1350 /* do not allow to set the mtp_property_inherited flag or
1351 * the automatic inheritance of flags will not work */
1352 ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited;
1356 /* Sets one additional graph property. */
1357 void set_entity_additional_property(entity *ent, mtp_additional_property flag)
1361 assert(is_method_entity(ent));
1363 /* first check, if the graph exists */
1364 irg = get_entity_irg(ent);
1366 set_irg_additional_property(irg, flag);
1368 unsigned mask = ent->attr.mtd_attr.irg_add_properties;
1370 if (mask & mtp_property_inherited)
1371 mask = get_method_additional_properties(get_entity_type(ent));
1373 /* do not allow to set the mtp_property_inherited flag or
1374 * the automatic inheritance of flags will not work */
1375 ent->attr.mtd_attr.irg_add_properties = mask | (flag & ~mtp_property_inherited);
1379 /* Initialize entity module. */
1380 void firm_init_entity(void)
1382 symconst_symbol sym;
1384 assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
1385 assert(!unknown_entity && "Call firm_init_entity() only once!");
1387 unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
1388 set_entity_visibility(unknown_entity, visibility_external_allocated);
1389 set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
1391 current_ir_graph = get_const_code_irg();
1392 sym.entity_p = unknown_entity;
1393 unknown_entity->value = new_SymConst(sym, symconst_addr_ent);