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 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, type *owner, ident *name, 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;
112 if (is_Method_type(type)) {
115 res->variability = variability_constant;
116 rem = current_ir_graph;
117 current_ir_graph = get_const_code_irg();
118 res->value = new_SymConst(sym, symconst_addr_ent);
119 current_ir_graph = rem;
120 res->irg_add_properties = 0;
123 res->variability = variability_uninitialized;
126 res->val_paths = NULL;
129 res->volatility = volatility_non_volatile;
130 res->stickyness = stickyness_unsticky;
133 res->peculiarity = peculiarity_existent;
135 if (is_Class_type(owner)) {
136 res->overwrites = NEW_ARR_F(entity *, 0);
137 res->overwrittenby = NEW_ARR_F(entity *, 0);
139 res->overwrites = NULL;
140 res->overwrittenby = NULL;
145 res->nr = get_irp_new_node_nr();
146 #endif /* DEBUG_libfirm */
149 set_entity_dbg_info(res, db);
155 new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
158 assert_legal_owner_of_ent(owner);
159 res = new_rd_entity(db, owner, name, type);
160 /* Remember entity in it's owner. */
161 insert_entity_in_owner (res);
163 hook_new_entity(res);
168 new_entity (type *owner, ident *name, type *type) {
169 return new_d_entity(owner, name, type, NULL);
175 static void free_entity_attrs(entity *ent) {
177 if (get_type_tpop(get_entity_owner(ent)) == type_class) {
178 DEL_ARR_F(ent->overwrites); ent->overwrites = NULL;
179 DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL;
181 assert(ent->overwrites == NULL);
182 assert(ent->overwrittenby == NULL);
184 /* if (ent->values) DEL_ARR_F(ent->values); *//* @@@ warum nich? */
185 if (ent->val_paths) {
186 if (is_compound_entity(ent))
187 for (i = 0; i < get_compound_ent_n_values(ent); i++)
188 if (ent->val_paths[i]) ;
189 /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */
190 /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
191 /* DEL_ARR_F(ent->val_paths); */
193 ent->val_paths = NULL;
198 copy_entity_own (entity *old, type *new_owner) {
200 assert(old && old->kind == k_entity);
201 assert_legal_owner_of_ent(new_owner);
203 if (old->owner == new_owner) return old;
204 newe = xmalloc(sizeof(*newe));
205 memcpy (newe, old, sizeof(*newe));
206 newe->owner = new_owner;
207 if (is_Class_type(new_owner)) {
208 newe->overwrites = NEW_ARR_F(entity *, 0);
209 newe->overwrittenby = NEW_ARR_F(entity *, 0);
212 newe->nr = get_irp_new_node_nr();
215 insert_entity_in_owner (newe);
221 copy_entity_name (entity *old, ident *new_name) {
223 assert(old && old->kind == k_entity);
225 if (old->name == new_name) return old;
226 newe = xmalloc(sizeof(*newe));
227 memcpy(newe, old, sizeof(*newe));
228 newe->name = new_name;
229 newe->ld_name = NULL;
230 if (is_Class_type(newe->owner)) {
231 newe->overwrites = DUP_ARR_F(entity *, old->overwrites);
232 newe->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
235 newe->nr = get_irp_new_node_nr();
238 insert_entity_in_owner (newe);
245 free_entity (entity *ent) {
246 assert(ent && ent->kind == k_entity);
247 free_entity_attrs(ent);
252 /* Outputs a unique number for this node */
254 get_entity_nr(entity *ent) {
255 assert(ent && ent->kind == k_entity);
264 (get_entity_name)(const entity *ent) {
265 return _get_entity_name(ent);
269 (get_entity_ident)(const entity *ent) {
270 return get_entity_ident(ent);
274 void set_entitye_ld_name (entity *, char *ld_name);
275 void set_entity_ld_ident (entity *, ident *ld_ident);
279 (get_entity_owner)(entity *ent) {
280 return _get_entity_owner(ent);
284 set_entity_owner (entity *ent, type *owner) {
285 assert(ent && ent->kind == k_entity);
286 assert_legal_owner_of_ent(owner);
290 void /* should this go into type.c? */
291 assert_legal_owner_of_ent(type *owner) {
292 assert(get_type_tpop_code(owner) == tpo_class ||
293 get_type_tpop_code(owner) == tpo_union ||
294 get_type_tpop_code(owner) == tpo_struct ||
295 get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity
296 -- to select fields! */
300 (get_entity_ld_ident)(entity *ent) {
301 return _get_entity_ld_ident(ent);
305 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
306 _set_entity_ld_ident(ent, ld_ident);
310 (get_entity_ld_name)(entity *ent) {
311 return _get_entity_ld_name(ent);
315 (get_entity_type)(entity *ent) {
316 return _get_entity_type(ent);
320 (set_entity_type)(entity *ent, type *type) {
321 _set_entity_type(ent, type);
325 (get_entity_allocation)(const entity *ent) {
326 return _get_entity_allocation(ent);
330 (set_entity_allocation)(entity *ent, ent_allocation al) {
331 _set_entity_allocation(ent, al);
334 /* return the name of the visibility */
335 const char *get_allocation_name(ent_allocation all)
337 #define X(a) case a: return #a
339 X(allocation_automatic);
340 X(allocation_parameter);
341 X(allocation_dynamic);
342 X(allocation_static);
343 default: return "BAD VALUE";
350 (get_entity_visibility)(const entity *ent) {
351 return _get_entity_visibility(ent);
355 set_entity_visibility (entity *ent, visibility vis) {
356 assert(ent && ent->kind == k_entity);
357 if (vis != visibility_local)
358 assert((ent->allocation == allocation_static) ||
359 (ent->allocation == allocation_automatic));
360 /* @@@ Test that the owner type is not local, but how??
361 && get_class_visibility(get_entity_owner(ent)) != local));*/
362 ent->visibility = vis;
365 /* return the name of the visibility */
366 const char *get_visibility_name(visibility vis)
368 #define X(a) case a: return #a
371 X(visibility_external_visible);
372 X(visibility_external_allocated);
373 default: return "BAD VALUE";
379 (get_entity_variability)(const entity *ent) {
380 return _get_entity_variability(ent);
384 set_entity_variability (entity *ent, ent_variability var)
386 assert(ent && ent->kind == k_entity);
387 if (var == variability_part_constant)
388 assert(is_Class_type(ent->type) || is_Struct_type(ent->type));
390 if ((is_compound_type(ent->type)) &&
391 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
392 /* Allocate datastructures for constant values */
393 ent->values = NEW_ARR_F(ir_node *, 0);
394 ent->val_paths = NEW_ARR_F(compound_graph_path *, 0);
396 if ((is_atomic_type(ent->type)) &&
397 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
398 /* Set default constant value. */
399 ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type));
402 if ((is_compound_type(ent->type)) &&
403 (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
404 /* Free datastructures for constant values */
405 DEL_ARR_F(ent->values); ent->values = NULL;
406 DEL_ARR_F(ent->val_paths); ent->val_paths = NULL;
408 ent->variability = var;
411 /* return the name of the variablity */
412 const char *get_variability_name(ent_variability var)
414 #define X(a) case a: return #a
416 X(variability_uninitialized);
417 X(variability_initialized);
418 X(variability_part_constant);
419 X(variability_constant);
420 default: return "BAD VALUE";
426 (get_entity_volatility)(const entity *ent) {
427 return _get_entity_volatility(ent);
431 (set_entity_volatility)(entity *ent, ent_volatility vol) {
432 _set_entity_volatility(ent, vol);
435 /* return the name of the volatility */
436 const char *get_volatility_name(ent_volatility var)
438 #define X(a) case a: return #a
440 X(volatility_non_volatile);
441 X(volatility_is_volatile);
442 default: return "BAD VALUE";
448 (get_entity_peculiarity)(const entity *ent) {
449 return _get_entity_peculiarity(ent);
453 (set_entity_peculiarity)(entity *ent, peculiarity pec) {
454 _set_entity_peculiarity(ent, pec);
457 /* return the name of the peculiarity */
458 const char *get_peculiarity_name(peculiarity var)
460 #define X(a) case a: return #a
462 X(peculiarity_description);
463 X(peculiarity_inherited);
464 X(peculiarity_existent);
465 default: return "BAD VALUE";
470 /* Get the entity's stickyness */
472 (get_entity_stickyness)(const entity *ent) {
473 return _get_entity_stickyness(ent);
476 /* Set the entity's stickyness */
478 (set_entity_stickyness)(entity *ent, ent_stickyness stickyness) {
479 _set_entity_stickyness(ent, stickyness);
482 /* Set has no effect for existent entities of type method. */
484 get_atomic_ent_value(entity *ent)
486 assert(ent && is_atomic_entity(ent));
487 assert(ent->variability != variability_uninitialized);
488 return skip_Id (ent->value);
492 set_atomic_ent_value(entity *ent, ir_node *val) {
493 assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
494 if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
499 /* Returns true if the the node is representable as code on
501 int is_irn_const_expression(ir_node *n) {
504 /* we are in danger iff an exception will arise. TODO: be more precisely,
505 * for instance Div. will NOT rise if divisor != 0
507 if (is_binop(n) && !is_fragile_op(n))
508 return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
511 switch(get_irn_opcode(n)) {
518 return is_irn_const_expression(get_irn_n(n, 0));
527 * Copies a firm subgraph that complies to the restrictions for
528 * constant expressions to current_block in current_ir_graph.
530 ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
534 /* @@@ GL I think we should implement this using the routines from irgopt for
535 dead node elimination/inlineing. */
538 switch (get_irn_opcode(n)) {
540 nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
543 nn = new_d_SymConst_type(dbg, get_SymConst_symbol(n), get_SymConst_kind(n),
544 get_SymConst_value_type(n));
547 nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)),
548 copy_const_value(dbg, get_Add_right(n)), m); break;
550 nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)),
551 copy_const_value(dbg, get_Sub_right(n)), m); break;
553 nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)),
554 copy_const_value(dbg, get_Mul_right(n)), m); break;
556 nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)),
557 copy_const_value(dbg, get_And_right(n)), m); break;
559 nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)),
560 copy_const_value(dbg, get_Or_right(n)), m); break;
562 nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)),
563 copy_const_value(dbg, get_Eor_right(n)), m); break;
565 nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break;
567 nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break;
569 nn = new_d_Unknown(dbg, m); break;
572 assert(0 && "opcode invalid or not implemented");
579 /* Creates a new compound graph path. */
580 compound_graph_path *
581 new_compound_graph_path(type *tp, int length) {
582 compound_graph_path *res;
584 assert(is_type(tp) && is_compound_type(tp));
587 res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->list[0]));
588 memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->list[0]));
589 res->kind = k_ir_compound_graph_path;
596 /* Frees an graph path object */
597 void free_compound_graph_path (compound_graph_path *gr) {
598 assert(gr && is_compound_graph_path(gr));
603 /* Returns non-zero if an object is a compound graph path */
604 int is_compound_graph_path(void *thing) {
605 return (get_kind(thing) == k_ir_compound_graph_path);
608 /* Checks whether the path up to pos is correct. If the path contains a NULL,
609 * assumes the path is not complete and returns 'true'. */
610 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
613 type *owner = gr->tp;
615 for (i = 0; i <= pos; i++) {
616 node = get_compound_graph_path_node(gr, i);
618 /* Path not yet complete. */
620 if (get_entity_owner(node) != owner)
622 owner = get_entity_type(node);
624 if (pos == get_compound_graph_path_length(gr))
625 if (!is_atomic_type(owner))
630 /* Returns the length of a graph path */
631 int get_compound_graph_path_length(compound_graph_path *gr) {
632 assert(gr && is_compound_graph_path(gr));
637 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
638 assert(gr && is_compound_graph_path(gr));
639 assert(pos >= 0 && pos < gr->len);
640 return gr->list[pos].node;
644 set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
645 assert(gr && is_compound_graph_path(gr));
646 assert(pos >= 0 && pos < gr->len);
647 assert(is_entity(node));
648 gr->list[pos].node = node;
649 assert(is_proper_compound_graph_path(gr, pos));
653 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
654 assert(gr && is_compound_graph_path(gr));
655 assert(pos >= 0 && pos < gr->len);
656 return gr->list[pos].index;
660 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
661 assert(gr && is_compound_graph_path(gr));
662 assert(pos >= 0 && pos < gr->len);
663 gr->list[pos].index = index;
666 /* A value of a compound entity is a pair of value and the corresponding path to a member of
669 add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
670 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
671 ARR_APP1 (ir_node *, ent->values, val);
672 ARR_APP1 (compound_graph_path *, ent->val_paths, path);
676 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
677 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
678 ent->values[pos] = val;
679 ent->val_paths[pos] = path;
683 get_compound_ent_n_values(entity *ent) {
684 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
685 return (ARR_LEN (ent->values));
689 get_compound_ent_value(entity *ent, int pos) {
690 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
691 return ent->values[pos];
694 compound_graph_path *
695 get_compound_ent_value_path(entity *ent, int pos) {
696 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
697 return ent->val_paths[pos];
701 * Returns non-zero, if two compound_graph_pathes are equal
703 static int equal_paths(compound_graph_path *path1, int *visited_indicees, compound_graph_path *path2) {
705 int len1 = get_compound_graph_path_length(path1);
706 int len2 = get_compound_graph_path_length(path2);
708 if (len2 > len1) return false;
710 for (i = 0; i < len1; i++) {
712 entity *node1 = get_compound_graph_path_node(path1, i);
713 entity *node2 = get_compound_graph_path_node(path2, i);
715 if (node1 != node2) return false;
717 tp = get_entity_owner(node1);
718 if (is_Array_type(tp)) {
721 /* Compute the index of this node. */
722 assert(get_array_n_dimensions(tp) == 1 && "multidim not implemented");
724 low = get_array_lower_bound_int(tp, 0);
725 if (low + visited_indicees[i] < get_compound_graph_path_array_index(path2, i)) {
726 visited_indicees[i]++;
730 assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
736 /* Returns the position of a value with the given path.
737 * The path must contain array indicees for all array element entities. */
738 int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
739 int i, n_paths = get_compound_ent_n_values(ent);
740 int *visited_indicees = (int *)xcalloc(get_compound_graph_path_length(path), sizeof(int));
741 for (i = 0; i < n_paths; i ++) {
742 if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, path))
749 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
750 printf("Entity %s : ", get_entity_name(ent));
751 for (j = 0; j < get_compound_graph_path_length(path); ++j) {
752 entity *node = get_compound_graph_path_node(path, j);
753 printf("%s", get_entity_name(node));
754 if (is_Array_type(get_entity_owner(node)))
755 printf("[%d]", get_compound_graph_path_array_index(path, j));
757 printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
761 assert(0 && "path not found");
765 /* Returns a constant value given the access path.
766 * The path must contain array indicees for all array element entities. */
767 ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path) {
768 return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
773 remove_compound_ent_value(entity *ent, entity *value_ent) {
775 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
776 for (i = 0; i < (ARR_LEN (ent->val_paths)); i++) {
777 compound_graph_path *path = ent->val_paths[i];
778 if (path->list[path->len-1].node == value_ent) {
779 for(; i < (ARR_LEN (ent->val_paths))-1; i++) {
780 ent->val_paths[i] = ent->val_paths[i+1];
781 ent->values[i] = ent->values[i+1];
783 ARR_SETLEN(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1);
784 ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1);
791 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
792 compound_graph_path *path;
793 type *owner_tp = get_entity_owner(member);
794 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
795 path = new_compound_graph_path(get_entity_type(ent), 1);
796 path->list[0].node = member;
797 if (is_Array_type(owner_tp)) {
801 assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
802 max = get_array_lower_bound_int(owner_tp, 0) -1;
803 for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
804 int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
809 path->list[0].index = max + 1;
811 add_compound_ent_value_w_path(ent, val, path);
814 /* Copies the firm subgraph referenced by val to const_code_irg and adds
815 the node as constant initialization to ent.
816 The subgraph may not contain control flow operations.
818 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
819 ir_graph *rem = current_ir_graph;
821 assert(get_entity_variability(ent) != variability_uninitialized);
822 current_ir_graph = get_const_code_irg();
824 val = copy_const_value(val);
825 add_compound_ent_value(ent, val, member);
826 current_ir_graph = rem;
829 /* Copies the value i of the entity to current_block in current_ir_graph.
831 copy_compound_ent_value(entity *ent, int pos) {
832 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
833 return copy_const_value(ent->values[pos+1]);
837 get_compound_ent_value_member(entity *ent, int pos) {
838 compound_graph_path *path;
839 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
840 path = get_compound_ent_value_path(ent, pos);
842 return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
846 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
847 compound_graph_path *path;
848 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
849 path = get_compound_ent_value_path(ent, pos);
850 set_compound_graph_path_node(path, 0, member);
851 set_compound_ent_value_w_path(ent, val, path, pos);
855 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
857 ir_graph *rem = current_ir_graph;
858 type *arrtp = get_entity_type(ent);
860 type *elttp = get_array_element_type(arrtp);
862 assert(is_Array_type(arrtp));
863 assert(get_array_n_dimensions(arrtp) == 1);
864 /* One bound is sufficient, the number of constant fields makes the
866 assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
867 assert(get_entity_variability(ent) != variability_uninitialized);
868 current_ir_graph = get_const_code_irg();
870 for (i = 0; i < num_vals; i++) {
871 val = new_Const_type(values[i], elttp);
872 add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
873 set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
875 current_ir_graph = rem;
878 int get_compound_ent_value_offset_bits(entity *ent, int pos) {
879 compound_graph_path *path;
883 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
885 path = get_compound_ent_value_path(ent, pos);
886 path_len = get_compound_graph_path_length(path);
888 for (i = 0; i < path_len; ++i) {
889 entity *node = get_compound_graph_path_node(path, i);
890 type *node_tp = get_entity_type(node);
891 type *owner_tp = get_entity_owner(node);
892 if (is_Array_type(owner_tp)) {
893 int size = get_type_size_bits(node_tp);
894 int align = get_type_alignment_bits(node_tp);
898 assert(size % align == 0);
899 /* ansonsten aufrunden */
901 offset += size * get_compound_graph_path_array_index(path, i);
903 offset += get_entity_offset_bits(node);
909 int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
910 int offset = get_compound_ent_value_offset_bits(ent, pos);
911 assert(offset % 8 == 0);
916 static void init_index(type *arr) {
920 assert(get_array_n_dimensions(arr) == 1);
922 if (has_array_lower_bound(arr, dim))
923 init = get_array_lower_bound_int(arr, 0) -1;
925 init = get_array_upper_bound_int(arr, 0) +1;
927 set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
931 static int get_next_index(entity *elem_ent) {
932 type *arr = get_entity_owner(elem_ent);
936 assert(get_array_n_dimensions(arr) == 1);
938 if (has_array_lower_bound(arr, dim)) {
939 next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
940 if (has_array_upper_bound(arr, dim)) {
941 int upper = get_array_upper_bound_int(arr, dim);
942 if (next == upper) next = get_array_lower_bound_int(arr, dim);
945 next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
946 if (has_array_lower_bound(arr, dim)) {
947 int upper = get_array_upper_bound_int(arr, dim);
948 if (next == upper) next = get_array_upper_bound_int(arr, dim);
952 set_entity_link(elem_ent, INT_TO_PTR(next));
956 /* Compute the array indices in compound graph paths of initialized entities.
958 * All arrays must have fixed lower and upper bounds. One array can
959 * have an open bound. If there are several open bounds, we do
960 * nothing. There must be initializer elements for all array
961 * elements. Uses the link field in the array element entities. The
962 * array bounds must be representable as ints.
964 * (If the bounds are not representable as ints we have to represent
965 * the indices as firm nodes. But still we must be able to
966 * evaluate the index against the upper bound.)
968 void compute_compound_ent_array_indicees(entity *ent) {
969 type *tp = get_entity_type(ent);
971 entity *unknown_bound_entity = NULL;
973 if (!is_compound_type(tp) ||
974 (ent->variability == variability_uninitialized)) return ;
976 n_vals = get_compound_ent_n_values(ent);
977 if (n_vals == 0) return;
979 /* We can not compute the indexes if there is more than one array
980 with an unknown bound. For this remember the first entity that
981 represents such an array. It could be ent. */
982 if (is_Array_type(tp)) {
985 assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
986 if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
987 unknown_bound_entity = ent;
990 /* Initialize the entity links to lower bound -1 and test all path elements
992 for (i = 0; i < n_vals; ++i) {
993 compound_graph_path *path = get_compound_ent_value_path(ent, i);
994 int j, path_len = get_compound_graph_path_length(path);
995 for (j = 0; j < path_len; ++j) {
996 entity *node = get_compound_graph_path_node(path, j);
997 type *elem_tp = get_entity_type(node);
999 if (is_Array_type(elem_tp)) {
1001 assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
1002 if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
1003 if (!unknown_bound_entity) unknown_bound_entity = node;
1004 if (node != unknown_bound_entity) return;
1007 init_index(elem_tp);
1012 /* Finally compute the indexes ... */
1013 for (i = 0; i < n_vals; ++i) {
1014 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1015 int j, path_len = get_compound_graph_path_length(path);
1016 for (j = 0; j < path_len; ++j) {
1017 entity *node = get_compound_graph_path_node(path, j);
1018 type *owner_tp = get_entity_owner(node);
1019 if (is_Array_type(owner_tp))
1020 set_compound_graph_path_array_index (path, j, get_next_index(node));
1025 /** resize: double the allocated buffer */
1026 static int *resize (int *buf, int *size) {
1027 int new_size = *size * 2;
1028 int *new_buf = xcalloc(new_size, sizeof(new_buf[0]));
1029 memcpy(new_buf, buf, *size);
1035 /* We sort the elements by placing them at their bit offset in an
1036 array where each entry represents one bit called permutation. In
1037 fact, we do not place the values themselves, as we would have to
1038 copy two things, the value and the path. We only remember the
1039 position in the old order. Each value should have a distinct
1040 position in the permutation.
1042 A second iteration now permutes the actual elements into two
1044 void sort_compound_ent_values(entity *ent) {
1052 ir_node **my_values;
1053 compound_graph_path **my_paths;
1055 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
1057 tp = get_entity_type(ent);
1058 n_vals = get_compound_ent_n_values(ent);
1059 tp_size = get_type_size_bits(tp);
1061 if (!is_compound_type(tp) ||
1062 (ent->variability == variability_uninitialized) ||
1063 (get_type_state(tp) != layout_fixed) ||
1064 (n_vals == 0) ) return;
1066 /* estimated upper bound for size. Better: use flexible array ... */
1067 size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
1068 permutation = xcalloc(size, sizeof(permutation[0]));
1070 for (i = 0; i < n_vals; ++i) {
1071 int pos = get_compound_ent_value_offset_bits(ent, i);
1072 while (pos >= size) {
1073 permutation = resize(permutation, &size);
1076 assert(permutation[pos] == 0 && "two values with the same offset");
1077 permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
1078 So inc all entries by one. */
1079 //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
1083 my_values = NEW_ARR_F(ir_node *, n_vals);
1084 my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
1085 for (i = 0; i < size; ++i) {
1086 int pos = permutation[i];
1088 //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next);
1089 assert(next < n_vals);
1090 pos--; /* We increased the pos by one */
1091 my_values[next] = get_compound_ent_value (ent, pos);
1092 my_paths [next] = get_compound_ent_value_path(ent, pos);
1098 DEL_ARR_F(ent->values);
1099 ent->values = my_values;
1100 DEL_ARR_F(ent->val_paths);
1101 ent->val_paths = my_paths;
1105 (get_entity_offset_bytes)(const entity *ent) {
1106 return _get_entity_offset_bytes(ent);
1110 (get_entity_offset_bits)(const entity *ent) {
1111 return _get_entity_offset_bits(ent);
1115 (set_entity_offset_bytes)(entity *ent, int offset) {
1116 _set_entity_offset_bytes(ent, offset);
1120 (set_entity_offset_bits)(entity *ent, int offset) {
1121 _set_entity_offset_bits(ent, offset);
1125 add_entity_overwrites(entity *ent, entity *overwritten) {
1126 assert(ent && is_Class_type(get_entity_owner(ent)));
1127 ARR_APP1(entity *, ent->overwrites, overwritten);
1128 ARR_APP1(entity *, overwritten->overwrittenby, ent);
1132 get_entity_n_overwrites(entity *ent) {
1133 assert(ent && is_Class_type(get_entity_owner(ent)));
1134 return (ARR_LEN(ent->overwrites));
1138 get_entity_overwrites_index(entity *ent, entity *overwritten) {
1140 assert(ent && is_Class_type(get_entity_owner(ent)));
1141 for (i = 0; i < get_entity_n_overwrites(ent); i++)
1142 if (get_entity_overwrites(ent, i) == overwritten)
1148 get_entity_overwrites (entity *ent, int pos) {
1149 assert(ent && is_Class_type(get_entity_owner(ent)));
1150 assert(pos < get_entity_n_overwrites(ent));
1151 return ent->overwrites[pos];
1155 set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
1156 assert(ent && is_Class_type(get_entity_owner(ent)));
1157 assert(pos < get_entity_n_overwrites(ent));
1158 ent->overwrites[pos] = overwritten;
1162 remove_entity_overwrites(entity *ent, entity *overwritten) {
1164 assert(ent && is_Class_type(get_entity_owner(ent)));
1165 for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1166 if (ent->overwrites[i] == overwritten) {
1167 for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1168 ent->overwrites[i] = ent->overwrites[i+1];
1169 ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1175 add_entity_overwrittenby (entity *ent, entity *overwrites) {
1176 assert(ent && is_Class_type(get_entity_owner(ent)));
1177 add_entity_overwrites(overwrites, ent);
1181 get_entity_n_overwrittenby (entity *ent) {
1182 assert(ent && is_Class_type(get_entity_owner(ent)));
1183 return (ARR_LEN (ent->overwrittenby));
1187 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1189 assert(ent && is_Class_type(get_entity_owner(ent)));
1190 for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1191 if (get_entity_overwrittenby(ent, i) == overwrites)
1197 get_entity_overwrittenby (entity *ent, int pos) {
1198 assert(ent && is_Class_type(get_entity_owner(ent)));
1199 assert(pos < get_entity_n_overwrittenby(ent));
1200 return ent->overwrittenby[pos];
1204 set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
1205 assert(ent && is_Class_type(get_entity_owner(ent)));
1206 assert(pos < get_entity_n_overwrittenby(ent));
1207 ent->overwrittenby[pos] = overwrites;
1210 void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1212 assert(ent && is_Class_type(get_entity_owner(ent)));
1213 for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1214 if (ent->overwrittenby[i] == overwrites) {
1215 for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1216 ent->overwrittenby[i] = ent->overwrittenby[i+1];
1217 ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1222 /* A link to store intermediate information */
1224 (get_entity_link)(const entity *ent) {
1225 return _get_entity_link(ent);
1229 (set_entity_link)(entity *ent, void *l) {
1230 _set_entity_link(ent, l);
1234 (get_entity_irg)(const entity *ent) {
1235 return _get_entity_irg(ent);
1239 set_entity_irg(entity *ent, ir_graph *irg) {
1240 assert(ent && is_Method_type(get_entity_type(ent)));
1241 /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1242 * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1243 * aber erhalten bleiben soll? Wandle die Entitaet in description oder
1246 assert((irg && ent->peculiarity == peculiarity_existent) ||
1247 (!irg && (ent->peculiarity == peculiarity_existent)
1248 && (ent -> visibility == visibility_external_allocated)) ||
1249 (!irg && ent->peculiarity == peculiarity_description) ||
1250 (!irg && ent->peculiarity == peculiarity_inherited));
1255 (is_entity)(const void *thing) {
1256 return _is_entity(thing);
1259 int is_atomic_entity(entity *ent) {
1260 type* t = get_entity_type(ent);
1261 assert(ent && ent->kind == k_entity);
1262 return (is_Primitive_type(t) || is_Pointer_type(t) ||
1263 is_Enumeration_type(t) || is_Method_type(t));
1266 int is_compound_entity(entity *ent) {
1267 type* t = get_entity_type(ent);
1268 assert(ent && ent->kind == k_entity);
1269 return (is_Class_type(t) || is_Struct_type(t) ||
1270 is_Array_type(t) || is_Union_type(t));
1274 * @todo not implemented!!! */
1275 bool equal_entity(entity *ent1, entity *ent2) {
1276 fprintf(stderr, " calling unimplemented equal entity!!! \n");
1281 unsigned long (get_entity_visited)(entity *ent) {
1282 return _get_entity_visited(ent);
1285 void (set_entity_visited)(entity *ent, unsigned long num) {
1286 _set_entity_visited(ent, num);
1289 /* Sets visited field in entity to entity_visited. */
1290 void (mark_entity_visited)(entity *ent) {
1291 _mark_entity_visited(ent);
1294 int (entity_visited)(entity *ent) {
1295 return _entity_visited(ent);
1298 int (entity_not_visited)(entity *ent) {
1299 return _entity_not_visited(ent);
1302 unsigned (get_entity_additional_properties)(const entity *ent) {
1303 return _get_entity_additional_properties(ent);
1306 void (set_entity_additional_properties)(entity *ent, unsigned property_mask) {
1307 _set_entity_additional_properties(ent, property_mask);
1310 void (set_entity_additional_property)(entity *ent, unsigned flag) {
1311 _set_entity_additional_property(ent, (irg_additional_property)flag);
1314 /* Returns the calling convention of an entities graph. */
1315 unsigned (get_entity_calling_convention)(const entity *ent) {
1316 return _get_entity_calling_convention(ent);
1319 /* Sets the calling convention of an entities graph. */
1320 void (set_entity_calling_convention)(entity *ent, unsigned cc_mask) {
1321 _set_entity_calling_convention(ent, cc_mask);
1324 void firm_init_entity(void)
1326 symconst_symbol sym;
1328 assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
1329 assert(!unknown_entity && "Call firm_init_entity() only once!");
1330 unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
1331 set_entity_visibility(unknown_entity, visibility_external_allocated);
1332 set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
1334 sym.entity_p = unknown_entity;
1335 current_ir_graph = get_const_code_irg();
1336 unknown_entity->value = new_SymConst(sym, symconst_addr_ent);