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;
116 res->peculiarity = peculiarity_existent;
119 if (is_Method_type(type)) {
122 rem = current_ir_graph;
123 current_ir_graph = get_const_code_irg();
124 res->value = new_SymConst(sym, symconst_addr_ent);
125 current_ir_graph = rem;
126 res->allocation = allocation_static;
127 res->variability = variability_constant;
128 res->attr.mtd_attr.irg_add_properties = mtp_property_inherited;
129 res->attr.mtd_attr.vtable_number = VTABLE_NUM_NOT_SET;
130 res->attr.mtd_attr.param_access = NULL;
131 res->attr.mtd_attr.param_weight = NULL;
132 res->attr.mtd_attr.irg = NULL;
133 res->attr.mtd_attr.section = section_text;
135 else if (is_compound_type(type)) {
136 res->variability = variability_uninitialized;
138 res->attr.cmpd_attr.values = NULL;
139 res->attr.cmpd_attr.val_paths = NULL;
142 res->variability = variability_uninitialized;
146 if (is_Class_type(owner)) {
147 res->overwrites = NEW_ARR_F(entity *, 0);
148 res->overwrittenby = NEW_ARR_F(entity *, 0);
150 res->overwrites = NULL;
151 res->overwrittenby = NULL;
155 res->nr = get_irp_new_node_nr();
156 #endif /* DEBUG_libfirm */
159 set_entity_dbg_info(res, db);
165 new_d_entity (ir_type *owner, ident *name, ir_type *type, dbg_info *db) {
168 assert_legal_owner_of_ent(owner);
169 res = new_rd_entity(db, owner, name, type);
170 /* Remember entity in it's owner. */
171 insert_entity_in_owner (res);
173 hook_new_entity(res);
178 new_entity (ir_type *owner, ident *name, ir_type *type) {
179 return new_d_entity(owner, name, type, NULL);
183 * Free entity attributes.
185 * @param ent the entity
187 static void free_entity_attrs(entity *ent) {
189 if (get_type_tpop(get_entity_owner(ent)) == type_class) {
190 DEL_ARR_F(ent->overwrites); ent->overwrites = NULL;
191 DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL;
193 assert(ent->overwrites == NULL);
194 assert(ent->overwrittenby == NULL);
196 if (is_compound_entity(ent)) {
197 if (ent->attr.cmpd_attr.val_paths) {
198 for (i = 0; i < get_compound_ent_n_values(ent); i++)
199 if (ent->attr.cmpd_attr.val_paths[i]) {
200 /* free_compound_graph_path(ent->attr.cmpd_attr.val_paths[i]) ; * @@@ warum nich? */
201 /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
202 /* DEL_ARR_F(ent->attr.cmpd_attr.val_paths); */
204 ent->attr.cmpd_attr.val_paths = NULL;
206 /* if (ent->attr.cmpd_attr.values) DEL_ARR_F(ent->attr.cmpd_attr.values); *//* @@@ warum nich? */
207 ent->attr.cmpd_attr.values = NULL;
209 else if (is_method_entity(ent)) {
210 if (ent->attr.mtd_attr.param_access) {
211 DEL_ARR_F(ent->attr.mtd_attr.param_access);
212 ent->attr.mtd_attr.param_access = NULL;
214 if (ent->attr.mtd_attr.param_weight) {
215 DEL_ARR_F(ent->attr.mtd_attr.param_weight);
216 ent->attr.mtd_attr.param_weight = NULL;
222 copy_entity_own (entity *old, ir_type *new_owner) {
224 assert(old && old->kind == k_entity);
225 assert_legal_owner_of_ent(new_owner);
227 if (old->owner == new_owner) return old;
228 newe = xmalloc(sizeof(*newe));
229 memcpy (newe, old, sizeof(*newe));
230 newe->owner = new_owner;
231 if (is_Class_type(new_owner)) {
232 newe->overwrites = NEW_ARR_F(entity *, 0);
233 newe->overwrittenby = NEW_ARR_F(entity *, 0);
236 newe->nr = get_irp_new_node_nr();
239 insert_entity_in_owner (newe);
245 copy_entity_name (entity *old, ident *new_name) {
247 assert(old && old->kind == k_entity);
249 if (old->name == new_name) return old;
250 newe = xmalloc(sizeof(*newe));
251 memcpy(newe, old, sizeof(*newe));
252 newe->name = new_name;
253 newe->ld_name = NULL;
254 if (is_Class_type(newe->owner)) {
255 newe->overwrites = DUP_ARR_F(entity *, old->overwrites);
256 newe->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
259 newe->nr = get_irp_new_node_nr();
262 insert_entity_in_owner (newe);
269 free_entity (entity *ent) {
270 assert(ent && ent->kind == k_entity);
271 free_entity_attrs(ent);
276 /* Outputs a unique number for this node */
278 get_entity_nr(entity *ent) {
279 assert(ent && ent->kind == k_entity);
283 return (long)PTR_TO_INT(ent);
288 (get_entity_name)(const entity *ent) {
289 return _get_entity_name(ent);
293 (get_entity_ident)(const entity *ent) {
294 return _get_entity_ident(ent);
298 (set_entity_ident)(entity *ent, ident *id) {
299 _set_entity_ident(ent, id);
303 (get_entity_owner)(entity *ent) {
304 return _get_entity_owner(ent);
308 set_entity_owner (entity *ent, ir_type *owner) {
309 assert(ent && ent->kind == k_entity);
310 assert_legal_owner_of_ent(owner);
314 void /* should this go into type.c? */
315 assert_legal_owner_of_ent(ir_type *owner) {
316 assert(get_type_tpop_code(owner) == tpo_class ||
317 get_type_tpop_code(owner) == tpo_union ||
318 get_type_tpop_code(owner) == tpo_struct ||
319 get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity
320 -- to select fields! */
324 (get_entity_ld_ident)(entity *ent) {
325 return _get_entity_ld_ident(ent);
329 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
330 _set_entity_ld_ident(ent, ld_ident);
334 (get_entity_ld_name)(entity *ent) {
335 return _get_entity_ld_name(ent);
339 (get_entity_type)(entity *ent) {
340 return _get_entity_type(ent);
344 (set_entity_type)(entity *ent, ir_type *type) {
345 _set_entity_type(ent, type);
349 (get_entity_allocation)(const entity *ent) {
350 return _get_entity_allocation(ent);
354 (set_entity_allocation)(entity *ent, ir_allocation al) {
355 _set_entity_allocation(ent, al);
358 /* return the name of the visibility */
359 const char *get_allocation_name(ir_allocation all)
361 #define X(a) case a: return #a
363 X(allocation_automatic);
364 X(allocation_parameter);
365 X(allocation_dynamic);
366 X(allocation_static);
367 default: return "BAD VALUE";
374 (get_entity_visibility)(const entity *ent) {
375 return _get_entity_visibility(ent);
379 set_entity_visibility(entity *ent, ir_visibility vis) {
380 assert(ent && ent->kind == k_entity);
381 if (vis != visibility_local)
382 assert((ent->allocation == allocation_static) ||
383 (ent->allocation == allocation_automatic));
384 /* @@@ Test that the owner type is not local, but how??
385 && get_class_visibility(get_entity_owner(ent)) != local));*/
386 ent->visibility = vis;
389 /* return the name of the visibility */
390 const char *get_visibility_name(ir_visibility vis)
392 #define X(a) case a: return #a
395 X(visibility_external_visible);
396 X(visibility_external_allocated);
397 default: return "BAD VALUE";
403 (get_entity_variability)(const entity *ent) {
404 return _get_entity_variability(ent);
408 set_entity_variability (entity *ent, ir_variability var)
410 assert(ent && ent->kind == k_entity);
411 if (var == variability_part_constant)
412 assert(is_Class_type(ent->type) || is_Struct_type(ent->type));
414 if ((is_compound_type(ent->type)) &&
415 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
416 /* Allocate data structures for constant values */
417 ent->attr.cmpd_attr.values = NEW_ARR_F(ir_node *, 0);
418 ent->attr.cmpd_attr.val_paths = NEW_ARR_F(compound_graph_path *, 0);
420 if ((is_atomic_type(ent->type)) &&
421 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
422 /* Set default constant value. */
423 ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type));
426 if ((is_compound_type(ent->type)) &&
427 (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
428 /* Free data structures for constant values */
429 DEL_ARR_F(ent->attr.cmpd_attr.values); ent->attr.cmpd_attr.values = NULL;
430 DEL_ARR_F(ent->attr.cmpd_attr.val_paths); ent->attr.cmpd_attr.val_paths = NULL;
432 ent->variability = var;
435 /* return the name of the variability */
436 const char *get_variability_name(ir_variability var)
438 #define X(a) case a: return #a
440 X(variability_uninitialized);
441 X(variability_initialized);
442 X(variability_part_constant);
443 X(variability_constant);
444 default: return "BAD VALUE";
450 (get_entity_volatility)(const entity *ent) {
451 return _get_entity_volatility(ent);
455 (set_entity_volatility)(entity *ent, ir_volatility vol) {
456 _set_entity_volatility(ent, vol);
459 /* return the name of the volatility */
460 const char *get_volatility_name(ir_volatility var)
462 #define X(a) case a: return #a
464 X(volatility_non_volatile);
465 X(volatility_is_volatile);
466 default: return "BAD VALUE";
472 (get_entity_peculiarity)(const entity *ent) {
473 return _get_entity_peculiarity(ent);
477 (set_entity_peculiarity)(entity *ent, ir_peculiarity pec) {
478 _set_entity_peculiarity(ent, pec);
481 /* Get the entity's stickyness */
483 (get_entity_stickyness)(const entity *ent) {
484 return _get_entity_stickyness(ent);
487 /* Set the entity's stickyness */
489 (set_entity_stickyness)(entity *ent, ir_stickyness stickyness) {
490 _set_entity_stickyness(ent, stickyness);
493 /* Set has no effect for existent entities of type method. */
495 get_atomic_ent_value(entity *ent)
497 assert(ent && is_atomic_entity(ent));
498 assert(ent->variability != variability_uninitialized);
499 return skip_Id (ent->value);
503 set_atomic_ent_value(entity *ent, ir_node *val) {
504 assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
505 if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
510 /* Returns true if the the node is representable as code on
512 int is_irn_const_expression(ir_node *n) {
515 /* we are in danger iff an exception will arise. TODO: be more precisely,
516 * for instance Div. will NOT rise if divisor != 0
518 if (is_binop(n) && !is_fragile_op(n))
519 return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
522 switch(get_irn_opcode(n)) {
529 return is_irn_const_expression(get_irn_n(n, 0));
537 * Copies a firm subgraph that complies to the restrictions for
538 * constant expressions to current_block in current_ir_graph.
540 ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
544 /* @@@ GL I think we should implement this using the routines from irgopt for
545 dead node elimination/inlineing. */
548 switch (get_irn_opcode(n)) {
550 nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
553 nn = new_d_SymConst_type(dbg, get_SymConst_symbol(n), get_SymConst_kind(n),
554 get_SymConst_value_type(n));
557 nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)),
558 copy_const_value(dbg, get_Add_right(n)), m); break;
560 nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)),
561 copy_const_value(dbg, get_Sub_right(n)), m); break;
563 nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)),
564 copy_const_value(dbg, get_Mul_right(n)), m); break;
566 nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)),
567 copy_const_value(dbg, get_And_right(n)), m); break;
569 nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)),
570 copy_const_value(dbg, get_Or_right(n)), m); break;
572 nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)),
573 copy_const_value(dbg, get_Eor_right(n)), m); break;
575 nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break;
577 nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break;
579 nn = new_d_Unknown(m); break;
582 assert(0 && "opcode invalid or not implemented");
589 /* Creates a new compound graph path. */
590 compound_graph_path *
591 new_compound_graph_path(ir_type *tp, int length) {
592 compound_graph_path *res;
594 assert(is_type(tp) && is_compound_type(tp));
597 res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->list[0]));
598 memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->list[0]));
599 res->kind = k_ir_compound_graph_path;
606 /* Frees an graph path object */
607 void free_compound_graph_path (compound_graph_path *gr) {
608 assert(gr && is_compound_graph_path(gr));
613 /* Returns non-zero if an object is a compound graph path */
614 int is_compound_graph_path(void *thing) {
615 return (get_kind(thing) == k_ir_compound_graph_path);
618 /* Checks whether the path up to pos is correct. If the path contains a NULL,
619 * assumes the path is not complete and returns 'true'. */
620 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
623 ir_type *owner = gr->tp;
625 for (i = 0; i <= pos; i++) {
626 node = get_compound_graph_path_node(gr, i);
628 /* Path not yet complete. */
630 if (get_entity_owner(node) != owner)
632 owner = get_entity_type(node);
634 if (pos == get_compound_graph_path_length(gr))
635 if (!is_atomic_type(owner))
640 /* Returns the length of a graph path */
641 int get_compound_graph_path_length(compound_graph_path *gr) {
642 assert(gr && is_compound_graph_path(gr));
647 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
648 assert(gr && is_compound_graph_path(gr));
649 assert(pos >= 0 && pos < gr->len);
650 return gr->list[pos].node;
654 set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
655 assert(gr && is_compound_graph_path(gr));
656 assert(pos >= 0 && pos < gr->len);
657 assert(is_entity(node));
658 gr->list[pos].node = node;
659 assert(is_proper_compound_graph_path(gr, pos));
663 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
664 assert(gr && is_compound_graph_path(gr));
665 assert(pos >= 0 && pos < gr->len);
666 return gr->list[pos].index;
670 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
671 assert(gr && is_compound_graph_path(gr));
672 assert(pos >= 0 && pos < gr->len);
673 gr->list[pos].index = index;
676 /* A value of a compound entity is a pair of value and the corresponding path to a member of
679 add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
680 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
681 assert(is_compound_graph_path(path));
682 ARR_APP1(ir_node *, ent->attr.cmpd_attr.values, val);
683 ARR_APP1(compound_graph_path *, ent->attr.cmpd_attr.val_paths, path);
687 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
688 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
689 assert(is_compound_graph_path(path));
690 assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
691 ent->attr.cmpd_attr.values[pos] = val;
692 ent->attr.cmpd_attr.val_paths[pos] = path;
696 get_compound_ent_n_values(entity *ent) {
697 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
698 return ARR_LEN(ent->attr.cmpd_attr.values);
702 get_compound_ent_value(entity *ent, int pos) {
703 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
704 assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
705 return ent->attr.cmpd_attr.values[pos];
708 compound_graph_path *
709 get_compound_ent_value_path(entity *ent, int pos) {
710 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
711 assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.val_paths));
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;
756 int path_len = get_compound_graph_path_length(path);
758 NEW_ARR_A(int *, visited_indicees, path_len);
759 memset(visited_indicees, 0, sizeof(*visited_indicees) * path_len);
760 for (i = 0; i < n_paths; i ++) {
761 if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, path))
768 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
769 printf("Entity %s : ", get_entity_name(ent));
770 for (j = 0; j < get_compound_graph_path_length(path); ++j) {
771 entity *node = get_compound_graph_path_node(path, j);
772 printf("%s", get_entity_name(node));
773 if (is_Array_type(get_entity_owner(node)))
774 printf("[%d]", get_compound_graph_path_array_index(path, j));
776 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
780 assert(0 && "path not found");
784 /* Returns a constant value given the access path.
785 * The path must contain array indicees for all array element entities. */
786 ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path) {
787 return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
792 remove_compound_ent_value(entity *ent, entity *value_ent) {
794 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
795 for (i = 0; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths)); ++i) {
796 compound_graph_path *path = ent->attr.cmpd_attr.val_paths[i];
797 if (path->list[path->len-1].node == value_ent) {
798 for (; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths))-1; ++i) {
799 ent->attr.cmpd_attr.val_paths[i] = ent->attr.cmpd_attr.val_paths[i+1];
800 ent->attr.cmpd_attr.values[i] = ent->attr.cmpd_attr.values[i+1];
802 ARR_SETLEN(entity*, ent->attr.cmpd_attr.val_paths, ARR_LEN(ent->attr.cmpd_attr.val_paths) - 1);
803 ARR_SETLEN(ir_node*, ent->attr.cmpd_attr.values, ARR_LEN(ent->attr.cmpd_attr.values) - 1);
810 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
811 compound_graph_path *path;
812 ir_type *owner_tp = get_entity_owner(member);
813 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
814 path = new_compound_graph_path(get_entity_type(ent), 1);
815 path->list[0].node = member;
816 if (is_Array_type(owner_tp)) {
820 assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
821 max = get_array_lower_bound_int(owner_tp, 0) -1;
822 for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
823 int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
828 path->list[0].index = max + 1;
830 add_compound_ent_value_w_path(ent, val, path);
833 /* Copies the firm subgraph referenced by val to const_code_irg and adds
834 the node as constant initialization to ent.
835 The subgraph may not contain control flow operations.
837 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
838 ir_graph *rem = current_ir_graph;
840 assert(get_entity_variability(ent) != variability_uninitialized);
841 current_ir_graph = get_const_code_irg();
843 val = copy_const_value(val);
844 add_compound_ent_value(ent, val, member);
845 current_ir_graph = rem;
848 /* Copies the value i of the entity to current_block in current_ir_graph.
850 copy_compound_ent_value(entity *ent, int pos) {
851 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
852 return copy_const_value(ent->values[pos+1]);
856 get_compound_ent_value_member(entity *ent, int pos) {
857 compound_graph_path *path;
858 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
859 path = get_compound_ent_value_path(ent, pos);
861 return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
865 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
866 compound_graph_path *path;
867 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
868 path = get_compound_ent_value_path(ent, pos);
869 set_compound_graph_path_node(path, 0, member);
870 set_compound_ent_value_w_path(ent, val, path, pos);
874 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
876 ir_graph *rem = current_ir_graph;
877 ir_type *arrtp = get_entity_type(ent);
879 ir_type *elttp = get_array_element_type(arrtp);
881 assert(is_Array_type(arrtp));
882 assert(get_array_n_dimensions(arrtp) == 1);
883 /* One bound is sufficient, the number of constant fields makes the
885 assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
886 assert(get_entity_variability(ent) != variability_uninitialized);
887 current_ir_graph = get_const_code_irg();
889 for (i = 0; i < num_vals; i++) {
890 val = new_Const_type(values[i], elttp);
891 add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
892 set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
894 current_ir_graph = rem;
897 int get_compound_ent_value_offset_bits(entity *ent, int pos) {
898 compound_graph_path *path;
902 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
904 path = get_compound_ent_value_path(ent, pos);
905 path_len = get_compound_graph_path_length(path);
907 for (i = 0; i < path_len; ++i) {
908 entity *node = get_compound_graph_path_node(path, i);
909 ir_type *node_tp = get_entity_type(node);
910 ir_type *owner_tp = get_entity_owner(node);
911 if (is_Array_type(owner_tp)) {
912 int size = get_type_size_bits(node_tp);
913 int align = get_type_alignment_bits(node_tp);
917 assert(size % align == 0);
918 /* ansonsten aufrunden */
920 offset += size * get_compound_graph_path_array_index(path, i);
922 offset += get_entity_offset_bits(node);
928 int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
929 int offset = get_compound_ent_value_offset_bits(ent, pos);
930 assert(offset % 8 == 0);
935 static void init_index(ir_type *arr) {
939 assert(get_array_n_dimensions(arr) == 1);
941 if (has_array_lower_bound(arr, dim))
942 init = get_array_lower_bound_int(arr, 0) -1;
944 init = get_array_upper_bound_int(arr, 0) +1;
946 set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
950 static int get_next_index(entity *elem_ent) {
951 ir_type *arr = get_entity_owner(elem_ent);
955 assert(get_array_n_dimensions(arr) == 1);
957 if (has_array_lower_bound(arr, dim)) {
958 next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
959 if (has_array_upper_bound(arr, dim)) {
960 int upper = get_array_upper_bound_int(arr, dim);
961 if (next == upper) next = get_array_lower_bound_int(arr, dim);
964 next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
965 if (has_array_lower_bound(arr, dim)) {
966 int upper = get_array_upper_bound_int(arr, dim);
967 if (next == upper) next = get_array_upper_bound_int(arr, dim);
971 set_entity_link(elem_ent, INT_TO_PTR(next));
975 /* Compute the array indices in compound graph paths of initialized entities.
977 * All arrays must have fixed lower and upper bounds. One array can
978 * have an open bound. If there are several open bounds, we do
979 * nothing. There must be initializer elements for all array
980 * elements. Uses the link field in the array element entities. The
981 * array bounds must be representable as ints.
983 * (If the bounds are not representable as ints we have to represent
984 * the indices as firm nodes. But still we must be able to
985 * evaluate the index against the upper bound.)
987 void compute_compound_ent_array_indicees(entity *ent) {
988 ir_type *tp = get_entity_type(ent);
990 entity *unknown_bound_entity = NULL;
992 if (!is_compound_type(tp) ||
993 (ent->variability == variability_uninitialized)) return ;
995 n_vals = get_compound_ent_n_values(ent);
996 if (n_vals == 0) return;
998 /* We can not compute the indexes if there is more than one array
999 with an unknown bound. For this remember the first entity that
1000 represents such an array. It could be ent. */
1001 if (is_Array_type(tp)) {
1004 assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
1005 if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
1006 unknown_bound_entity = ent;
1009 /* Initialize the entity links to lower bound -1 and test all path elements
1010 for known bounds. */
1011 for (i = 0; i < n_vals; ++i) {
1012 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1013 int j, path_len = get_compound_graph_path_length(path);
1014 for (j = 0; j < path_len; ++j) {
1015 entity *node = get_compound_graph_path_node(path, j);
1016 ir_type *elem_tp = get_entity_type(node);
1018 if (is_Array_type(elem_tp)) {
1020 assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
1021 if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
1022 if (!unknown_bound_entity) unknown_bound_entity = node;
1023 if (node != unknown_bound_entity) return;
1026 init_index(elem_tp);
1031 /* Finally compute the indexes ... */
1032 for (i = 0; i < n_vals; ++i) {
1033 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1034 int j, path_len = get_compound_graph_path_length(path);
1035 for (j = 0; j < path_len; ++j) {
1036 entity *node = get_compound_graph_path_node(path, j);
1037 ir_type *owner_tp = get_entity_owner(node);
1038 if (is_Array_type(owner_tp))
1039 set_compound_graph_path_array_index (path, j, get_next_index(node));
1044 /** resize: double the allocated buffer */
1045 static int *resize (int *buf, int *size) {
1046 int new_size = *size * 2;
1047 int *new_buf = xcalloc(new_size, sizeof(new_buf[0]));
1048 memcpy(new_buf, buf, *size);
1054 /* We sort the elements by placing them at their bit offset in an
1055 array where each entry represents one bit called permutation. In
1056 fact, we do not place the values themselves, as we would have to
1057 copy two things, the value and the path. We only remember the
1058 position in the old order. Each value should have a distinct
1059 position in the permutation.
1061 A second iteration now permutes the actual elements into two
1063 void sort_compound_ent_values(entity *ent) {
1071 ir_node **my_values;
1072 compound_graph_path **my_paths;
1074 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
1076 tp = get_entity_type(ent);
1077 n_vals = get_compound_ent_n_values(ent);
1078 tp_size = get_type_size_bits(tp);
1080 if (!is_compound_type(tp) ||
1081 (ent->variability == variability_uninitialized) ||
1082 (get_type_state(tp) != layout_fixed) ||
1083 (n_vals == 0) ) return;
1085 /* estimated upper bound for size. Better: use flexible array ... */
1086 size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
1087 permutation = xcalloc(size, sizeof(permutation[0]));
1089 for (i = 0; i < n_vals; ++i) {
1090 int pos = get_compound_ent_value_offset_bits(ent, i);
1091 while (pos >= size) {
1092 permutation = resize(permutation, &size);
1095 assert(permutation[pos] == 0 && "two values with the same offset");
1096 permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
1097 So inc all entries by one. */
1098 //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
1102 my_values = NEW_ARR_F(ir_node *, n_vals);
1103 my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
1104 for (i = 0; i < size; ++i) {
1105 int pos = permutation[i];
1107 //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next);
1108 assert(next < n_vals);
1109 pos--; /* We increased the pos by one */
1110 my_values[next] = get_compound_ent_value (ent, pos);
1111 my_paths [next] = get_compound_ent_value_path(ent, pos);
1117 DEL_ARR_F(ent->attr.cmpd_attr.values);
1118 ent->attr.cmpd_attr.values = my_values;
1119 DEL_ARR_F(ent->attr.cmpd_attr.val_paths);
1120 ent->attr.cmpd_attr.val_paths = my_paths;
1124 (get_entity_offset_bytes)(const entity *ent) {
1125 return _get_entity_offset_bytes(ent);
1129 (get_entity_offset_bits)(const entity *ent) {
1130 return _get_entity_offset_bits(ent);
1134 (set_entity_offset_bytes)(entity *ent, int offset) {
1135 _set_entity_offset_bytes(ent, offset);
1139 (set_entity_offset_bits)(entity *ent, int offset) {
1140 _set_entity_offset_bits(ent, offset);
1144 add_entity_overwrites(entity *ent, entity *overwritten) {
1145 assert(ent && is_Class_type(get_entity_owner(ent)));
1146 ARR_APP1(entity *, ent->overwrites, overwritten);
1147 ARR_APP1(entity *, overwritten->overwrittenby, ent);
1151 get_entity_n_overwrites(entity *ent) {
1152 assert(ent && is_Class_type(get_entity_owner(ent)));
1153 return (ARR_LEN(ent->overwrites));
1157 get_entity_overwrites_index(entity *ent, entity *overwritten) {
1159 assert(ent && is_Class_type(get_entity_owner(ent)));
1160 for (i = 0; i < get_entity_n_overwrites(ent); i++)
1161 if (get_entity_overwrites(ent, i) == overwritten)
1167 get_entity_overwrites (entity *ent, int pos) {
1168 assert(ent && is_Class_type(get_entity_owner(ent)));
1169 assert(pos < get_entity_n_overwrites(ent));
1170 return ent->overwrites[pos];
1174 set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
1175 assert(ent && is_Class_type(get_entity_owner(ent)));
1176 assert(pos < get_entity_n_overwrites(ent));
1177 ent->overwrites[pos] = overwritten;
1181 remove_entity_overwrites(entity *ent, entity *overwritten) {
1183 assert(ent && is_Class_type(get_entity_owner(ent)));
1184 for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1185 if (ent->overwrites[i] == overwritten) {
1186 for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1187 ent->overwrites[i] = ent->overwrites[i+1];
1188 ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1194 add_entity_overwrittenby (entity *ent, entity *overwrites) {
1195 assert(ent && is_Class_type(get_entity_owner(ent)));
1196 add_entity_overwrites(overwrites, ent);
1200 get_entity_n_overwrittenby (entity *ent) {
1201 assert(ent && is_Class_type(get_entity_owner(ent)));
1202 return (ARR_LEN (ent->overwrittenby));
1206 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1208 assert(ent && is_Class_type(get_entity_owner(ent)));
1209 for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1210 if (get_entity_overwrittenby(ent, i) == overwrites)
1216 get_entity_overwrittenby (entity *ent, int pos) {
1217 assert(ent && is_Class_type(get_entity_owner(ent)));
1218 assert(pos < get_entity_n_overwrittenby(ent));
1219 return ent->overwrittenby[pos];
1223 set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
1224 assert(ent && is_Class_type(get_entity_owner(ent)));
1225 assert(pos < get_entity_n_overwrittenby(ent));
1226 ent->overwrittenby[pos] = overwrites;
1229 void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1231 assert(ent && is_Class_type(get_entity_owner(ent)));
1232 for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1233 if (ent->overwrittenby[i] == overwrites) {
1234 for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1235 ent->overwrittenby[i] = ent->overwrittenby[i+1];
1236 ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1241 /* A link to store intermediate information */
1243 (get_entity_link)(const entity *ent) {
1244 return _get_entity_link(ent);
1248 (set_entity_link)(entity *ent, void *l) {
1249 _set_entity_link(ent, l);
1253 (get_entity_irg)(const entity *ent) {
1254 return _get_entity_irg(ent);
1258 set_entity_irg(entity *ent, ir_graph *irg) {
1259 assert(ent && is_method_entity(ent));
1260 /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1261 * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1262 * aber erhalten bleiben soll? Wandle die Entitaet in description oder
1265 assert((irg && ent->peculiarity == peculiarity_existent) ||
1266 (!irg && (ent->peculiarity == peculiarity_existent)
1267 && (ent -> visibility == visibility_external_allocated)) ||
1268 (!irg && ent->peculiarity == peculiarity_description) ||
1269 (!irg && ent->peculiarity == peculiarity_inherited));
1270 ent->attr.mtd_attr.irg = irg;
1273 unsigned get_entity_vtable_number(entity *ent) {
1274 assert(ent && is_method_entity(ent));
1275 return ent->attr.mtd_attr.vtable_number;
1278 void set_entity_vtable_number(entity *ent, unsigned vtable_number) {
1279 assert(ent && is_method_entity(ent));
1280 ent->attr.mtd_attr.vtable_number = vtable_number;
1283 /* Returns the section of a method. */
1284 ir_img_section get_method_img_section(const entity *ent) {
1285 assert(ent && is_method_entity(ent));
1286 return ent->attr.mtd_attr.section;
1289 /* Sets the section of a method. */
1290 void set_method_img_section(entity *ent, ir_img_section section) {
1291 assert(ent && is_method_entity(ent));
1292 ent->attr.mtd_attr.section = section;
1296 (is_entity)(const void *thing) {
1297 return _is_entity(thing);
1300 int is_atomic_entity(entity *ent) {
1301 ir_type *t = get_entity_type(ent);
1302 assert(ent && ent->kind == k_entity);
1303 return (is_Primitive_type(t) || is_Pointer_type(t) ||
1304 is_Enumeration_type(t) || is_Method_type(t));
1307 int is_compound_entity(entity *ent) {
1308 ir_type *t = get_entity_type(ent);
1309 assert(ent && ent->kind == k_entity);
1310 return (is_Class_type(t) || is_Struct_type(t) ||
1311 is_Array_type(t) || is_Union_type(t));
1314 int is_method_entity(entity *ent) {
1315 ir_type *t = get_entity_type(ent);
1316 assert(ent && ent->kind == k_entity);
1317 return (is_Method_type(t));
1321 * @todo not implemented!!! */
1322 int equal_entity(entity *ent1, entity *ent2) {
1323 fprintf(stderr, " calling unimplemented equal entity!!! \n");
1328 unsigned long (get_entity_visited)(entity *ent) {
1329 return _get_entity_visited(ent);
1332 void (set_entity_visited)(entity *ent, unsigned long num) {
1333 _set_entity_visited(ent, num);
1336 /* Sets visited field in entity to entity_visited. */
1337 void (mark_entity_visited)(entity *ent) {
1338 _mark_entity_visited(ent);
1341 int (entity_visited)(entity *ent) {
1342 return _entity_visited(ent);
1345 int (entity_not_visited)(entity *ent) {
1346 return _entity_not_visited(ent);
1349 /* Returns the mask of the additional entity properties. */
1350 unsigned get_entity_additional_properties(entity *ent) {
1353 assert(is_method_entity(ent));
1355 /* first check, if the graph has additional properties */
1356 irg = get_entity_irg(ent);
1359 return get_irg_additional_properties(irg);
1361 if (ent->attr.mtd_attr.irg_add_properties & mtp_property_inherited)
1362 return get_method_additional_properties(get_entity_type(ent));
1364 return ent->attr.mtd_attr.irg_add_properties;
1367 /* Sets the mask of the additional graph properties. */
1368 void set_entity_additional_properties(entity *ent, unsigned property_mask)
1372 assert(is_method_entity(ent));
1374 /* first check, if the graph exists */
1375 irg = get_entity_irg(ent);
1377 set_irg_additional_properties(irg, property_mask);
1379 /* do not allow to set the mtp_property_inherited flag or
1380 * the automatic inheritance of flags will not work */
1381 ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited;
1385 /* Sets one additional graph property. */
1386 void set_entity_additional_property(entity *ent, mtp_additional_property flag)
1390 assert(is_method_entity(ent));
1392 /* first check, if the graph exists */
1393 irg = get_entity_irg(ent);
1395 set_irg_additional_property(irg, flag);
1397 unsigned mask = ent->attr.mtd_attr.irg_add_properties;
1399 if (mask & mtp_property_inherited)
1400 mask = get_method_additional_properties(get_entity_type(ent));
1402 /* do not allow to set the mtp_property_inherited flag or
1403 * the automatic inheritance of flags will not work */
1404 ent->attr.mtd_attr.irg_add_properties = mask | (flag & ~mtp_property_inherited);
1408 /* Initialize entity module. */
1409 void firm_init_entity(void)
1411 symconst_symbol sym;
1413 assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
1414 assert(!unknown_entity && "Call firm_init_entity() only once!");
1416 unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
1417 set_entity_visibility(unknown_entity, visibility_external_allocated);
1418 set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
1420 current_ir_graph = get_const_code_irg();
1421 sym.entity_p = unknown_entity;
1422 unknown_entity->value = new_SymConst(sym, symconst_addr_ent);