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.
21 # include "entity_t.h"
23 # include "typegmod.h"
25 /* All this is needed to build the constant node for methods: */
26 # include "irprog_t.h"
30 /*******************************************************************/
32 /*******************************************************************/
39 /*-----------------------------------------------------------------*/
41 /*-----------------------------------------------------------------*/
43 static void insert_entity_in_owner (entity *ent) {
44 type *owner = ent->owner;
45 switch (get_type_tpop_code(owner)) {
47 add_class_member (owner, ent);
50 add_struct_member (owner, ent);
53 add_union_member (owner, ent);
56 set_array_element_entity(owner, ent);
63 new_entity (type *owner, ident *name, type *type)
68 assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
70 res = (entity *) xmalloc (sizeof (entity));
72 assert_legal_owner_of_ent(owner);
77 if (get_type_tpop(type) == type_method)
78 res->allocation = allocation_static;
80 res->allocation = allocation_automatic;
82 res->visibility = visibility_local;
84 if (is_method_type(type)) {
87 res->variability = variability_constant;
88 rem = current_ir_graph;
89 current_ir_graph = get_const_code_irg();
90 res->value = new_SymConst(sym, symconst_addr_ent);
91 current_ir_graph = rem;
93 res->variability = variability_uninitialized;
96 res->val_paths = NULL;
98 res->peculiarity = peculiarity_existent;
99 res->volatility = volatility_non_volatile;
100 res->stickyness = stickyness_unsticky;
102 if (is_class_type(owner)) {
103 res->overwrites = NEW_ARR_F(entity *, 0);
104 res->overwrittenby = NEW_ARR_F(entity *, 0);
106 res->overwrites = NULL;
107 res->overwrittenby = NULL;
112 res->nr = get_irp_new_node_nr();
117 /* Remember entity in it's owner. */
118 insert_entity_in_owner (res);
122 new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
123 entity *res = new_entity(owner, name, type);
124 set_entity_dbg_info(res, db);
128 static void free_entity_attrs(entity *ent) {
130 if (get_type_tpop(get_entity_owner(ent)) == type_class) {
131 DEL_ARR_F(ent->overwrites); ent->overwrites = NULL;
132 DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL;
134 assert(ent->overwrites == NULL);
135 assert(ent->overwrittenby == NULL);
137 /* if (ent->values) DEL_ARR_F(ent->values); *//* @@@ warum nich? */
138 if (ent->val_paths) {
139 if (is_compound_entity(ent))
140 for (i = 0; i < get_compound_ent_n_values(ent); i++)
141 if (ent->val_paths[i]) ;
142 /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */
143 /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
144 /* DEL_ARR_F(ent->val_paths); */
146 ent->val_paths = NULL;
151 copy_entity_own (entity *old, type *new_owner) {
153 assert(old && old->kind == k_entity);
154 assert_legal_owner_of_ent(new_owner);
156 if (old->owner == new_owner) return old;
157 new = (entity *) xmalloc (sizeof (entity));
158 memcpy (new, old, sizeof (entity));
159 new->owner = new_owner;
160 if (is_class_type(new_owner)) {
161 new->overwrites = NEW_ARR_F(entity *, 0);
162 new->overwrittenby = NEW_ARR_F(entity *, 0);
165 new->nr = get_irp_new_node_nr();
168 insert_entity_in_owner (new);
174 copy_entity_name (entity *old, ident *new_name) {
176 assert(old && old->kind == k_entity);
178 if (old->name == new_name) return old;
179 new = (entity *) xmalloc (sizeof (entity));
180 memcpy (new, old, sizeof (entity));
181 new->name = new_name;
183 if (is_class_type(new->owner)) {
184 new->overwrites = DUP_ARR_F(entity *, old->overwrites);
185 new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
188 new->nr = get_irp_new_node_nr();
191 insert_entity_in_owner (new);
198 free_entity (entity *ent) {
199 assert(ent && ent->kind == k_entity);
200 free_tarval_entity(ent);
201 free_entity_attrs(ent);
206 /* Outputs a unique number for this node */
208 get_entity_nr(entity *ent) {
209 assert(ent && ent->kind == k_entity);
218 (get_entity_name)(entity *ent) {
219 return __get_entity_name(ent);
223 (get_entity_ident)(entity *ent) {
224 return get_entity_ident(ent);
228 void set_entitye_ld_name (entity *, char *ld_name);
229 void set_entity_ld_ident (entity *, ident *ld_ident);
233 (get_entity_owner)(entity *ent) {
234 return __get_entity_owner(ent);
238 set_entity_owner (entity *ent, type *owner) {
239 assert(ent && ent->kind == k_entity);
240 assert_legal_owner_of_ent(owner);
244 void /* should this go into type.c? */
245 assert_legal_owner_of_ent(type *owner) {
246 assert(get_type_tpop_code(owner) == tpo_class ||
247 get_type_tpop_code(owner) == tpo_union ||
248 get_type_tpop_code(owner) == tpo_struct ||
249 get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity
250 -- to select fields! */
254 (get_entity_ld_ident)(entity *ent) {
255 return __get_entity_ld_ident(ent);
259 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
260 __set_entity_ld_ident(ent, ld_ident);
264 (get_entity_ld_name)(entity *ent) {
265 return __get_entity_ld_name(ent);
269 (get_entity_type)(entity *ent) {
270 return __get_entity_type(ent);
274 (set_entity_type)(entity *ent, type *type) {
275 __set_entity_type(ent, type);
279 (get_entity_allocation)(entity *ent) {
280 return __get_entity_allocation(ent);
284 (set_entity_allocation)(entity *ent, ent_allocation al) {
285 __set_entity_allocation(ent, al);
288 /* return the name of the visibility */
289 const char *get_allocation_name(ent_allocation all)
291 #define X(a) case a: return #a
293 X(allocation_automatic);
294 X(allocation_parameter);
295 X(allocation_dynamic);
296 X(allocation_static);
297 default: return "BAD VALUE";
304 (get_entity_visibility)(entity *ent) {
305 return __get_entity_visibility(ent);
309 set_entity_visibility (entity *ent, ent_visibility vis) {
310 assert(ent && ent->kind == k_entity);
311 if (vis != visibility_local)
312 assert((ent->allocation == allocation_static) ||
313 (ent->allocation == allocation_automatic));
314 /* @@@ Test that the owner type is not local, but how??
315 && get_class_visibility(get_entity_owner(ent)) != local));*/
316 ent->visibility = vis;
319 /* return the name of the visibility */
320 const char *get_visibility_name(ent_visibility vis)
322 #define X(a) case a: return #a
325 X(visibility_external_visible);
326 X(visibility_external_allocated);
327 default: return "BAD VALUE";
333 (get_entity_variability)(entity *ent) {
334 return __get_entity_variability(ent);
338 set_entity_variability (entity *ent, ent_variability var)
340 assert(ent && ent->kind == k_entity);
341 if (var == variability_part_constant)
342 assert(is_class_type(ent->type) || is_struct_type(ent->type));
344 if ((is_compound_type(ent->type)) &&
345 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
346 /* Allocate datastructures for constant values */
347 ent->values = NEW_ARR_F(ir_node *, 0);
348 ent->val_paths = NEW_ARR_F(compound_graph_path *, 0);
351 if ((is_compound_type(ent->type)) &&
352 (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
353 /* Free datastructures for constant values */
354 DEL_ARR_F(ent->values); ent->values = NULL;
355 DEL_ARR_F(ent->val_paths); ent->val_paths = NULL;
357 ent->variability = var;
360 /* return the name of the variablity */
361 const char *get_variability_name(ent_variability var)
363 #define X(a) case a: return #a
365 X(variability_uninitialized);
366 X(variability_initialized);
367 X(variability_part_constant);
368 X(variability_constant);
369 default: return "BAD VALUE";
375 (get_entity_volatility)(entity *ent) {
376 return __get_entity_volatility(ent);
380 (set_entity_volatility)(entity *ent, ent_volatility vol) {
381 __set_entity_volatility(ent, vol);
384 /* return the name of the volatility */
385 const char *get_volatility_name(ent_volatility var)
387 #define X(a) case a: return #a
389 X(volatility_non_volatile);
390 X(volatility_is_volatile);
391 default: return "BAD VALUE";
397 (get_entity_peculiarity)(entity *ent) {
398 return __get_entity_peculiarity(ent);
402 (set_entity_peculiarity)(entity *ent, peculiarity pec) {
403 __set_entity_peculiarity(ent, pec);
406 /* return the name of the peculiarity */
407 const char *get_peculiarity_name(peculiarity var)
409 #define X(a) case a: return #a
411 X(peculiarity_description);
412 X(peculiarity_inherited);
413 X(peculiarity_existent);
414 default: return "BAD VALUE";
419 /* Get the entity's stickyness */
421 (get_entity_stickyness)(entity *ent) {
422 return __get_entity_stickyness(ent);
425 /* Set the entity's stickyness */
427 (set_entity_stickyness)(entity *ent, ent_stickyness stickyness) {
428 __set_entity_stickyness(ent, stickyness);
431 /* Set has no effect for existent entities of type method. */
433 get_atomic_ent_value(entity *ent)
435 assert(ent && is_atomic_entity(ent));
436 assert(ent->variability != variability_uninitialized);
437 return skip_Id (ent->value);
441 set_atomic_ent_value(entity *ent, ir_node *val) {
442 assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
443 if (is_method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
448 /* Returns true if the the node is representable as code on
450 int is_irn_const_expression(ir_node *n) {
454 switch(get_irn_opcode(n)) {
465 if (is_irn_const_expression(get_binop_left(n)))
466 return is_irn_const_expression(get_binop_right(n));
469 return is_irn_const_expression(get_irn_n(n, 0));
478 ir_node *copy_const_value(ir_node *n) {
483 switch(get_irn_opcode(n)) {
485 nn = new_Const(m, get_Const_tarval(n)); break;
488 nn = new_SymConst(get_SymConst_symbol(n), get_SymConst_kind(n));
491 nn = new_Add(copy_const_value(get_Add_left(n)),
492 copy_const_value(get_Add_right(n)), m); break;
494 nn = new_Sub(copy_const_value(get_Sub_left(n)),
495 copy_const_value(get_Sub_right(n)), m); break;
497 nn = new_Mul(copy_const_value(get_Mul_left(n)),
498 copy_const_value(get_Mul_right(n)), m); break;
500 nn = new_And(copy_const_value(get_And_left(n)),
501 copy_const_value(get_And_right(n)), m); break;
503 nn = new_Or(copy_const_value(get_Or_left(n)),
504 copy_const_value(get_Or_right(n)), m); break;
506 nn = new_Eor(copy_const_value(get_Eor_left(n)),
507 copy_const_value(get_Eor_right(n)), m); break;
509 nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
511 nn = new_Conv(copy_const_value(get_Conv_op(n)), m); break;
513 nn = new_Unknown(m); break;
516 assert(0 && "opdope invalid or not implemented");
523 compound_graph_path *
524 new_compound_graph_path(type *tp, int length) {
525 compound_graph_path *res;
526 assert(is_type(tp) && is_compound_type(tp));
529 res = (compound_graph_path *) calloc (1, sizeof(compound_graph_path) + (length-1) * sizeof(entity *));
530 res->kind = k_ir_compound_graph_path;
533 res ->arr_indicees = (int *) calloc(length, sizeof(int));
538 free_compound_graph_path (compound_graph_path *gr) {
539 assert(gr && is_compound_graph_path(gr));
541 free(gr ->arr_indicees);
546 is_compound_graph_path(void *thing) {
547 return (get_kind(thing) == k_ir_compound_graph_path);
550 /* checks whether nodes 0..pos are correct (all lie on a path.) */
551 /* @@@ not implemented */
552 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
555 type *owner = gr->tp;
556 for (i = 0; i <= pos; i++) {
557 node = get_compound_graph_path_node(gr, i);
558 if (get_entity_owner(node) != owner) return false;
559 owner = get_entity_type(node);
561 if (pos == get_compound_graph_path_length(gr))
562 if (!is_atomic_type(owner)) return false;
567 get_compound_graph_path_length(compound_graph_path *gr) {
568 assert(gr && is_compound_graph_path(gr));
573 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
574 assert(gr && is_compound_graph_path(gr));
575 assert(pos >= 0 && pos < gr->len);
576 return gr->nodes[pos];
580 set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
581 assert(gr && is_compound_graph_path(gr));
582 assert(pos >= 0 && pos < gr->len);
583 assert(is_entity(node));
584 gr->nodes[pos] = node;
585 assert(is_proper_compound_graph_path(gr, pos));
589 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
590 assert(gr && is_compound_graph_path(gr));
591 assert(pos >= 0 && pos < gr->len);
592 return gr->arr_indicees[pos];
596 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
597 assert(gr && is_compound_graph_path(gr));
598 assert(pos >= 0 && pos < gr->len);
599 gr->arr_indicees[pos] = index;
602 /* A value of a compound entity is a pair of value and the corresponding path to a member of
605 add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
606 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
607 ARR_APP1 (ir_node *, ent->values, val);
608 ARR_APP1 (compound_graph_path *, ent->val_paths, path);
612 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
613 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
614 ent->values[pos] = val;
615 ent->val_paths[pos] = path;
619 get_compound_ent_n_values(entity *ent) {
620 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
621 return (ARR_LEN (ent->values));
625 get_compound_ent_value(entity *ent, int pos) {
626 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
627 return ent->values[pos];
630 compound_graph_path *
631 get_compound_ent_value_path(entity *ent, int pos) {
632 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
633 return ent->val_paths[pos];
637 remove_compound_ent_value(entity *ent, entity *value_ent) {
639 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
640 for (i = 0; i < (ARR_LEN (ent->val_paths)); i++) {
641 compound_graph_path *path = ent->val_paths[i];
642 if (path->nodes[path->len-1] == value_ent) {
643 for(; i < (ARR_LEN (ent->val_paths))-1; i++) {
644 ent->val_paths[i] = ent->val_paths[i+1];
645 ent->values[i] = ent->values[i+1];
647 ARR_SETLEN(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1);
648 ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1);
655 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
656 compound_graph_path *path;
657 type *owner_tp = get_entity_owner(ent);
658 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
659 path = new_compound_graph_path(owner_tp, 1);
660 path->nodes[0] = member;
661 if (is_array_type(owner_tp)) {
665 assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
666 max = get_array_lower_bound_int(owner_tp, 0) -1;
667 for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
668 int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
673 path->arr_indicees[0] = max + 1;
675 add_compound_ent_value_w_path(ent, val, path);
678 /* Copies the firm subgraph referenced by val to const_code_irg and adds
679 the node as constant initialization to ent.
680 The subgraph may not contain control flow operations.
682 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
683 ir_graph *rem = current_ir_graph;
685 assert(get_entity_variability(ent) != variability_uninitialized);
686 current_ir_graph = get_const_code_irg();
688 val = copy_const_value(val);
689 add_compound_ent_value(ent, val, member);
690 current_ir_graph = rem;
693 /* Copies the value i of the entity to current_block in current_ir_graph.
695 copy_compound_ent_value(entity *ent, int pos) {
696 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
697 return copy_const_value(ent->values[pos+1]);
701 get_compound_ent_value_member(entity *ent, int pos) {
702 compound_graph_path *path;
703 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
704 path = get_compound_ent_value_path(ent, pos);
706 return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
710 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
711 compound_graph_path *path;
712 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
713 path = get_compound_ent_value_path(ent, pos);
714 set_compound_graph_path_node(path, 0, member);
715 set_compound_ent_value_w_path(ent, val, path, pos);
719 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
721 ir_graph *rem = current_ir_graph;
722 type *arrtp = get_entity_type(ent);
725 assert(is_array_type(arrtp));
726 assert(get_array_n_dimensions(arrtp) == 1);
727 /* One bound is sufficient, the nunmber of constant fields makes the
729 assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
730 assert(get_entity_variability(ent) != variability_uninitialized);
731 current_ir_graph = get_const_code_irg();
733 for (i = 0; i < num_vals; i++) {
734 val = new_Const(get_tarval_mode (values[i]), values[i]);
735 add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
736 set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
738 current_ir_graph = rem;
741 int get_compound_ent_value_offset_bits(entity *ent, int pos) {
742 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
744 compound_graph_path *path = get_compound_ent_value_path(ent, pos);
745 int i, path_len = get_compound_graph_path_length(path);
748 for (i = 0; i < path_len; ++i) {
749 entity *node = get_compound_graph_path_node(path, i);
750 type *node_tp = get_entity_type(node);
751 type *owner_tp = get_entity_owner(node);
752 if (is_array_type(owner_tp)) {
753 int size = get_mode_size_bits (get_type_mode(node_tp));
754 int align = get_mode_align_bits(get_type_mode(node_tp));
758 assert(size % align == 0);
759 /* ansonsten aufrunden */
761 offset += size * get_compound_graph_path_array_index(path, i);
763 offset += get_entity_offset_bits(node);
769 int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
770 int offset = get_compound_ent_value_offset_bits(ent, pos);
771 assert(offset % 8 == 0);
776 static void init_index(type *arr) {
780 assert(get_array_n_dimensions(arr) == 1);
782 if (has_array_lower_bound(arr, dim))
783 init = get_array_lower_bound_int(arr, 0) -1;
785 init = get_array_upper_bound_int(arr, 0) +1;
787 set_entity_link(get_array_element_entity(arr), (void *)init);
791 static int get_next_index(entity *elem_ent) {
792 type *arr = get_entity_owner(elem_ent);
796 assert(get_array_n_dimensions(arr) == 1);
798 if (has_array_lower_bound(arr, dim)) {
799 next = (int)get_entity_link(elem_ent) +1;
800 if (has_array_upper_bound(arr, dim)) {
801 int upper = get_array_upper_bound_int(arr, dim);
802 if (next == upper) next = get_array_lower_bound_int(arr, dim);
805 next = (int)get_entity_link(elem_ent) -1;
806 if (has_array_lower_bound(arr, dim)) {
807 int upper = get_array_upper_bound_int(arr, dim);
808 if (next == upper) next = get_array_upper_bound_int(arr, dim);
812 set_entity_link(elem_ent, (void *)next);
816 /* Compute the array indicees in compound graph paths of initialized entities.
818 * All arrays must have fixed lower and upper bounds. One array can
819 * have an open bound. If there are several open bounds, we do
820 * nothing. There must be initializer elements for all array
821 * elements. Uses the link field in the array element entities. The
822 * array bounds must be representable as ints.
824 * (If the bounds are not representable as ints we have to represent
825 * the indicees as firm nodes. But the still we must be able to
826 * evaluate the index against the upper bound.)
828 void compute_compound_ent_array_indicees(entity *ent) {
829 type *tp = get_entity_type(ent);
831 entity *unknown_bound_entity = NULL;
833 if (!is_compound_type(tp) ||
834 (ent->variability == variability_uninitialized)) return ;
836 n_vals = get_compound_ent_n_values(ent);
837 if (n_vals == 0) return;
839 /* We can not compute the indicees if there is more than one array
840 with an unknown bound. For this remember the first entity that
841 represents such an array. It could be ent. */
842 if (is_array_type(tp)) {
843 assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
845 if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
846 unknown_bound_entity = ent;
849 /* Initialize the entity links to lower bound -1 and test all path elements
851 for (i = 0; i < n_vals; ++i) {
852 compound_graph_path *path = get_compound_ent_value_path(ent, i);
853 int j, path_len = get_compound_graph_path_length(path);
854 for (j = 0; j < path_len; ++j) {
855 entity *node = get_compound_graph_path_node(path, j);
856 type *elem_tp = get_entity_type(node);
858 if (is_array_type(elem_tp)) {
859 assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
861 if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
862 if (!unknown_bound_entity) unknown_bound_entity = node;
863 if (node != unknown_bound_entity) return;
871 /* Finally compute the indicees ... */
872 for (i = 0; i < n_vals; ++i) {
873 compound_graph_path *path = get_compound_ent_value_path(ent, i);
874 int j, path_len = get_compound_graph_path_length(path);
875 for (j = 0; j < path_len; ++j) {
876 entity *node = get_compound_graph_path_node(path, j);
877 type *owner_tp = get_entity_owner(node);
878 if (is_array_type(owner_tp))
879 set_compound_graph_path_array_index (path, j, get_next_index(node));
886 static int *resize (int *buf, int new_size) {
887 int *new_buf = (int *)calloc(new_size, 4);
888 memcpy(new_buf, buf, new_size>1);
893 /* We sort the elements by placing them at their bit offset in an
894 array where each entry represents one bit called permutation. In
895 fact, we do not place the values themselves, as we would have to
896 copy two things, the value and the path. We only remember the
897 position in the old order. Each value should have a distinct
898 position in the permutation.
900 A second iteration now permutes the actual elements into two
902 void sort_compound_ent_values(entity *ent) {
903 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
905 type *tp = get_entity_type(ent);
906 int i, n_vals = get_compound_ent_n_values(ent);
907 int tp_size = get_type_size_bits(tp);
911 if (!is_compound_type(tp) ||
912 (ent->variability == variability_uninitialized) ||
913 (get_type_state(tp) != layout_fixed) ||
914 (n_vals == 0) ) return;
916 /* estimated upper bound for size. Better: use flexible array ... */
917 size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
918 permutation = (int *)calloc(size, 4);
919 for (i = 0; i < n_vals; ++i) {
920 int pos = get_compound_ent_value_offset_bits(ent, i);
921 while (pos >= size) {
923 permutation = resize(permutation, size);
926 assert(permutation[pos] == 0 && "two values with the same offset");
927 permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
928 So inc all entries by one. */
929 //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
933 ir_node **my_values = NEW_ARR_F(ir_node *, n_vals);
934 compound_graph_path **my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
935 for (i = 0; i < size; ++i) {
936 int pos = permutation[i];
938 //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next);
939 assert(next < n_vals);
940 pos--; /* We increased the pos by one */
941 my_values[next] = get_compound_ent_value (ent, pos);
942 my_paths [next] = get_compound_ent_value_path(ent, pos);
948 DEL_ARR_F(ent->values);
949 ent->values = my_values;
950 DEL_ARR_F(ent->val_paths);
951 ent->val_paths = my_paths;
955 (get_entity_offset_bytes)(entity *ent) {
956 return __get_entity_offset_bytes(ent);
960 (get_entity_offset_bits)(entity *ent) {
961 return __get_entity_offset_bits(ent);
965 (set_entity_offset_bytes)(entity *ent, int offset) {
966 __set_entity_offset_bytes(ent, offset);
970 (set_entity_offset_bits)(entity *ent, int offset) {
971 __set_entity_offset_bits(ent, offset);
975 add_entity_overwrites(entity *ent, entity *overwritten) {
976 assert(ent && is_class_type(get_entity_owner(ent)));
977 ARR_APP1(entity *, ent->overwrites, overwritten);
978 ARR_APP1(entity *, overwritten->overwrittenby, ent);
982 get_entity_n_overwrites(entity *ent) {
983 assert(ent && is_class_type(get_entity_owner(ent)));
984 return (ARR_LEN(ent->overwrites));
988 get_entity_overwrites_index(entity *ent, entity *overwritten) {
990 assert(ent && is_class_type(get_entity_owner(ent)));
991 for (i = 0; i < get_entity_n_overwrites(ent); i++)
992 if (get_entity_overwrites(ent, i) == overwritten)
998 get_entity_overwrites (entity *ent, int pos) {
999 assert(ent && is_class_type(get_entity_owner(ent)));
1000 assert(pos < get_entity_n_overwrites(ent));
1001 return ent->overwrites[pos];
1005 set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
1006 assert(ent && is_class_type(get_entity_owner(ent)));
1007 assert(pos < get_entity_n_overwrites(ent));
1008 ent->overwrites[pos] = overwritten;
1012 remove_entity_overwrites(entity *ent, entity *overwritten) {
1014 assert(ent && is_class_type(get_entity_owner(ent)));
1015 for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1016 if (ent->overwrites[i] == overwritten) {
1017 for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1018 ent->overwrites[i] = ent->overwrites[i+1];
1019 ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1025 add_entity_overwrittenby (entity *ent, entity *overwrites) {
1026 assert(ent && is_class_type(get_entity_owner(ent)));
1027 add_entity_overwrites(overwrites, ent);
1031 get_entity_n_overwrittenby (entity *ent) {
1032 assert(ent && is_class_type(get_entity_owner(ent)));
1033 return (ARR_LEN (ent->overwrittenby));
1037 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1039 assert(ent && is_class_type(get_entity_owner(ent)));
1040 for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1041 if (get_entity_overwrittenby(ent, i) == overwrites)
1047 get_entity_overwrittenby (entity *ent, int pos) {
1048 assert(ent && is_class_type(get_entity_owner(ent)));
1049 assert(pos < get_entity_n_overwrittenby(ent));
1050 return ent->overwrittenby[pos];
1054 set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
1055 assert(ent && is_class_type(get_entity_owner(ent)));
1056 assert(pos < get_entity_n_overwrittenby(ent));
1057 ent->overwrittenby[pos] = overwrites;
1060 void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1062 assert(ent && is_class_type(get_entity_owner(ent)));
1063 for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1064 if (ent->overwrittenby[i] == overwrites) {
1065 for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1066 ent->overwrittenby[i] = ent->overwrittenby[i+1];
1067 ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1072 /* A link to store intermediate information */
1074 (get_entity_link)(entity *ent) {
1075 return __get_entity_link(ent);
1079 (set_entity_link)(entity *ent, void *l) {
1080 __set_entity_link(ent, l);
1084 (get_entity_irg)(entity *ent) {
1085 return __get_entity_irg(ent);
1089 set_entity_irg(entity *ent, ir_graph *irg) {
1090 assert(ent && is_method_type(get_entity_type(ent)));
1091 /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1092 * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1093 * aber erhalten bleiben soll. */
1095 assert((irg && ent->peculiarity == peculiarity_existent) ||
1096 (!irg && ent->peculiarity == peculiarity_description) ||
1097 (!irg && ent->peculiarity == peculiarity_inherited));
1102 (is_entity)(void *thing) {
1103 return __is_entity(thing);
1106 int is_atomic_entity(entity *ent) {
1107 type* t = get_entity_type(ent);
1108 assert(ent && ent->kind == k_entity);
1109 return (is_primitive_type(t) || is_pointer_type(t) ||
1110 is_enumeration_type(t) || is_method_type(t));
1113 int is_compound_entity(entity *ent) {
1114 type* t = get_entity_type(ent);
1115 assert(ent && ent->kind == k_entity);
1116 return (is_class_type(t) || is_struct_type(t) ||
1117 is_array_type(t) || is_union_type(t));
1121 * @todo not implemnted!!! */
1122 bool equal_entity(entity *ent1, entity *ent2) {
1123 fprintf(stderr, " calling unimplemented equal entity!!! \n");
1128 unsigned long get_entity_visited(entity *ent) {
1129 assert(ent && ent->kind == k_entity);
1132 void set_entity_visited(entity *ent, unsigned long num) {
1133 assert(ent && ent->kind == k_entity);
1136 /* Sets visited field in entity to entity_visited. */
1137 void mark_entity_visited(entity *ent) {
1138 assert(ent && ent->kind == k_entity);
1139 ent->visit = type_visited;
1143 bool entity_visited(entity *ent) {
1144 assert(ent && ent->kind == k_entity);
1145 return get_entity_visited(ent) >= type_visited;
1148 bool entity_not_visited(entity *ent) {
1149 assert(ent && ent->kind == k_entity);
1150 return get_entity_visited(ent) < type_visited;
1153 /* Need two routines because I want to assert the result. */
1154 static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) {
1155 int i, n_overwrittenby;
1158 if (get_entity_owner(static_ent) == dynamic_class) return static_ent;
1160 n_overwrittenby = get_entity_n_overwrittenby(static_ent);
1161 for (i = 0; i < n_overwrittenby; ++i) {
1162 res = resolve_ent_polymorphy2(dynamic_class, get_entity_overwrittenby(static_ent, i));
1169 /** Resolve polymorphy in the inheritance relation.
1171 * Returns the dynamically referenced entity if the static entity and the
1172 * dynamic type are given.
1173 * Search downwards in overwritten tree. */
1174 entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent) {
1176 assert(static_ent && static_ent->kind == k_entity);
1178 res = resolve_ent_polymorphy2(dynamic_class, static_ent);
1180 printf(" Could not find entity "); DDME(static_ent);
1181 printf(" in "); DDMT(dynamic_class);
1183 dump_entity(static_ent);
1184 dump_type(get_entity_owner(static_ent));
1185 dump_type(dynamic_class);
1193 /*******************************************************************/
1195 /*******************************************************************/
1198 #if 1 || DEBUG_libfirm
1199 int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */
1201 #define X(a) case a: printf(#a); break
1202 void dump_entity (entity *ent) {
1204 type *owner = get_entity_owner(ent);
1205 type *type = get_entity_type(ent);
1206 assert(ent && ent->kind == k_entity);
1207 printf("entity %s (%ld)\n", get_entity_name(ent), get_entity_nr(ent));
1208 printf(" type: %s (%ld)\n", get_type_name(type), get_type_nr(type));
1209 printf(" owner: %s (%ld)\n", get_type_name(owner), get_type_nr(owner));
1211 if (get_entity_n_overwrites(ent) > 0) {
1212 printf(" overwrites:\n");
1213 for (i = 0; i < get_entity_n_overwrites(ent); ++i) {
1214 entity *ov = get_entity_overwrites(ent, i);
1215 printf(" %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov)));
1218 printf(" Does not overwrite other entities. \n");
1220 if (get_entity_n_overwrittenby(ent) > 0) {
1221 printf(" overwritten by:\n");
1222 for (i = 0; i < get_entity_n_overwrittenby(ent); ++i) {
1223 entity *ov = get_entity_overwrittenby(ent, i);
1224 printf(" %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov)));
1227 printf(" Is not overwriten by other entities. \n");
1230 printf(" allocation: ");
1231 switch (get_entity_allocation(ent)) {
1232 X(allocation_dynamic);
1233 X(allocation_automatic);
1234 X(allocation_static);
1235 X(allocation_parameter);
1238 printf("\n visibility: ");
1239 switch (get_entity_visibility(ent)) {
1240 X(visibility_local);
1241 X(visibility_external_visible);
1242 X(visibility_external_allocated);
1245 printf("\n variability: ");
1246 switch (get_entity_variability(ent)) {
1247 X(variability_uninitialized);
1248 X(variability_initialized);
1249 X(variability_part_constant);
1250 X(variability_constant);
1253 if (get_entity_variability(ent) != variability_uninitialized) {
1254 if (is_atomic_entity(ent)) {
1255 printf("\n atomic value: ");
1256 dump_node_opcode(stdout, get_atomic_ent_value(ent));
1258 printf("\n compound values:");
1259 for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
1260 compound_graph_path *path = get_compound_ent_value_path(ent, i);
1261 entity *ent0 = get_compound_graph_path_node(path, 0);
1262 printf("\n %3d ", get_entity_offset_bits(ent0));
1263 if (get_type_state(type) == layout_fixed)
1264 printf("(%3d) ", get_compound_ent_value_offset_bits(ent, i));
1265 printf("%s", get_entity_name(ent0));
1266 for (j = 0; j < get_compound_graph_path_length(path); ++j) {
1267 entity *node = get_compound_graph_path_node(path, j);
1268 printf(".%s", get_entity_name(node));
1269 if (is_array_type(get_entity_owner(node)))
1270 printf("[%d]", get_compound_graph_path_array_index(path, j));
1273 dump_node_opcode(stdout, get_compound_ent_value(ent, i));
1278 printf("\n volatility: ");
1279 switch (get_entity_volatility(ent)) {
1280 X(volatility_non_volatile);
1281 X(volatility_is_volatile);
1284 printf("\n peculiarity: %s", get_peculiarity_string(get_entity_peculiarity(ent)));
1285 printf("\n ld_name: %s", ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
1286 printf("\n offset: %d", get_entity_offset_bits(ent));
1287 if (is_method_type(get_entity_type(ent))) {
1288 if (get_entity_irg(ent)) /* can be null */
1289 { printf("\n irg = %ld", get_irg_graph_nr(get_entity_irg(ent))); }
1291 { printf("\n irg = NULL"); }
1296 #else /* DEBUG_libfirm */
1297 void dump_entity (entity *ent) {}
1298 #endif /* DEBUG_libfirm */