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.
13 #include "firm_common_t.h"
19 # include "entity_t.h"
21 # include "typegmod.h"
24 /* All this is needed to build the constant node for methods: */
25 # include "irprog_t.h"
30 # include "irdump.h" /* for output if errors occur. */
33 # include "callgraph.h" /* for dumping debug output */
35 /*******************************************************************/
37 /*******************************************************************/
44 /*-----------------------------------------------------------------*/
46 /*-----------------------------------------------------------------*/
48 static void insert_entity_in_owner (entity *ent) {
49 type *owner = ent->owner;
50 switch (get_type_tpop_code(owner)) {
52 add_class_member (owner, ent);
55 add_struct_member (owner, ent);
58 add_union_member (owner, ent);
61 set_array_element_entity(owner, ent);
68 new_entity (type *owner, ident *name, type *type)
73 assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
75 res = (entity *) xmalloc (sizeof (entity));
77 assert_legal_owner_of_ent(owner);
82 if (get_type_tpop(type) == type_method)
83 res->allocation = allocation_static;
85 res->allocation = allocation_automatic;
87 res->visibility = visibility_local;
89 if (is_method_type(type)) {
92 res->variability = variability_constant;
93 rem = current_ir_graph;
94 current_ir_graph = get_const_code_irg();
95 res->value = new_SymConst(sym, symconst_addr_ent);
96 current_ir_graph = rem;
98 res->variability = variability_uninitialized;
101 res->val_paths = NULL;
103 res->peculiarity = peculiarity_existent;
104 res->volatility = volatility_non_volatile;
105 res->stickyness = stickyness_unsticky;
107 if (is_class_type(owner)) {
108 res->overwrites = NEW_ARR_F(entity *, 0);
109 res->overwrittenby = NEW_ARR_F(entity *, 0);
111 res->overwrites = NULL;
112 res->overwrittenby = NULL;
116 res->accesses = NULL;
119 res->nr = get_irp_new_node_nr();
124 /* Remember entity in it's owner. */
125 insert_entity_in_owner (res);
129 new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
130 entity *res = new_entity(owner, name, type);
131 set_entity_dbg_info(res, db);
135 static void free_entity_attrs(entity *ent) {
137 if (get_type_tpop(get_entity_owner(ent)) == type_class) {
138 DEL_ARR_F(ent->overwrites); ent->overwrites = NULL;
139 DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL;
141 assert(ent->overwrites == NULL);
142 assert(ent->overwrittenby == NULL);
144 /* if (ent->values) DEL_ARR_F(ent->values); *//* @@@ warum nich? */
145 if (ent->val_paths) {
146 if (is_compound_entity(ent))
147 for (i = 0; i < get_compound_ent_n_values(ent); i++)
148 if (ent->val_paths[i]) ;
149 /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */
150 /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
151 /* DEL_ARR_F(ent->val_paths); */
153 ent->val_paths = NULL;
158 copy_entity_own (entity *old, type *new_owner) {
160 assert(old && old->kind == k_entity);
161 assert_legal_owner_of_ent(new_owner);
163 if (old->owner == new_owner) return old;
164 new = (entity *) xmalloc (sizeof (entity));
165 memcpy (new, old, sizeof (entity));
166 new->owner = new_owner;
167 if (is_class_type(new_owner)) {
168 new->overwrites = NEW_ARR_F(entity *, 0);
169 new->overwrittenby = NEW_ARR_F(entity *, 0);
172 new->nr = get_irp_new_node_nr();
175 insert_entity_in_owner (new);
181 copy_entity_name (entity *old, ident *new_name) {
183 assert(old && old->kind == k_entity);
185 if (old->name == new_name) return old;
186 new = (entity *) xmalloc (sizeof (entity));
187 memcpy (new, old, sizeof (entity));
188 new->name = new_name;
190 if (is_class_type(new->owner)) {
191 new->overwrites = DUP_ARR_F(entity *, old->overwrites);
192 new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
195 new->nr = get_irp_new_node_nr();
198 insert_entity_in_owner (new);
205 free_entity (entity *ent) {
206 assert(ent && ent->kind == k_entity);
207 free_entity_attrs(ent);
212 /* Outputs a unique number for this node */
214 get_entity_nr(entity *ent) {
215 assert(ent && ent->kind == k_entity);
224 (get_entity_name)(entity *ent) {
225 return __get_entity_name(ent);
229 (get_entity_ident)(entity *ent) {
230 return get_entity_ident(ent);
234 void set_entitye_ld_name (entity *, char *ld_name);
235 void set_entity_ld_ident (entity *, ident *ld_ident);
239 (get_entity_owner)(entity *ent) {
240 return __get_entity_owner(ent);
244 set_entity_owner (entity *ent, type *owner) {
245 assert(ent && ent->kind == k_entity);
246 assert_legal_owner_of_ent(owner);
250 void /* should this go into type.c? */
251 assert_legal_owner_of_ent(type *owner) {
252 assert(get_type_tpop_code(owner) == tpo_class ||
253 get_type_tpop_code(owner) == tpo_union ||
254 get_type_tpop_code(owner) == tpo_struct ||
255 get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity
256 -- to select fields! */
260 (get_entity_ld_ident)(entity *ent) {
261 return __get_entity_ld_ident(ent);
265 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
266 __set_entity_ld_ident(ent, ld_ident);
270 (get_entity_ld_name)(entity *ent) {
271 return __get_entity_ld_name(ent);
275 (get_entity_type)(entity *ent) {
276 return __get_entity_type(ent);
280 (set_entity_type)(entity *ent, type *type) {
281 __set_entity_type(ent, type);
285 (get_entity_allocation)(entity *ent) {
286 return __get_entity_allocation(ent);
290 (set_entity_allocation)(entity *ent, ent_allocation al) {
291 __set_entity_allocation(ent, al);
294 /* return the name of the visibility */
295 const char *get_allocation_name(ent_allocation all)
297 #define X(a) case a: return #a
299 X(allocation_automatic);
300 X(allocation_parameter);
301 X(allocation_dynamic);
302 X(allocation_static);
303 default: return "BAD VALUE";
310 (get_entity_visibility)(entity *ent) {
311 return __get_entity_visibility(ent);
315 set_entity_visibility (entity *ent, ent_visibility vis) {
316 assert(ent && ent->kind == k_entity);
317 if (vis != visibility_local)
318 assert((ent->allocation == allocation_static) ||
319 (ent->allocation == allocation_automatic));
320 /* @@@ Test that the owner type is not local, but how??
321 && get_class_visibility(get_entity_owner(ent)) != local));*/
322 ent->visibility = vis;
325 /* return the name of the visibility */
326 const char *get_visibility_name(ent_visibility vis)
328 #define X(a) case a: return #a
331 X(visibility_external_visible);
332 X(visibility_external_allocated);
333 default: return "BAD VALUE";
339 (get_entity_variability)(entity *ent) {
340 return __get_entity_variability(ent);
344 set_entity_variability (entity *ent, ent_variability var)
346 assert(ent && ent->kind == k_entity);
347 if (var == variability_part_constant)
348 assert(is_class_type(ent->type) || is_struct_type(ent->type));
350 if ((is_compound_type(ent->type)) &&
351 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
352 /* Allocate datastructures for constant values */
353 ent->values = NEW_ARR_F(ir_node *, 0);
354 ent->val_paths = NEW_ARR_F(compound_graph_path *, 0);
356 if ((is_atomic_type(ent->type)) &&
357 (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
358 /* Set default constant value. */
359 ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type));
362 if ((is_compound_type(ent->type)) &&
363 (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
364 /* Free datastructures for constant values */
365 DEL_ARR_F(ent->values); ent->values = NULL;
366 DEL_ARR_F(ent->val_paths); ent->val_paths = NULL;
368 ent->variability = var;
371 /* return the name of the variablity */
372 const char *get_variability_name(ent_variability var)
374 #define X(a) case a: return #a
376 X(variability_uninitialized);
377 X(variability_initialized);
378 X(variability_part_constant);
379 X(variability_constant);
380 default: return "BAD VALUE";
386 (get_entity_volatility)(entity *ent) {
387 return __get_entity_volatility(ent);
391 (set_entity_volatility)(entity *ent, ent_volatility vol) {
392 __set_entity_volatility(ent, vol);
395 /* return the name of the volatility */
396 const char *get_volatility_name(ent_volatility var)
398 #define X(a) case a: return #a
400 X(volatility_non_volatile);
401 X(volatility_is_volatile);
402 default: return "BAD VALUE";
408 (get_entity_peculiarity)(entity *ent) {
409 return __get_entity_peculiarity(ent);
413 (set_entity_peculiarity)(entity *ent, peculiarity pec) {
414 __set_entity_peculiarity(ent, pec);
417 /* return the name of the peculiarity */
418 const char *get_peculiarity_name(peculiarity var)
420 #define X(a) case a: return #a
422 X(peculiarity_description);
423 X(peculiarity_inherited);
424 X(peculiarity_existent);
425 default: return "BAD VALUE";
430 /* Get the entity's stickyness */
432 (get_entity_stickyness)(entity *ent) {
433 return __get_entity_stickyness(ent);
436 /* Set the entity's stickyness */
438 (set_entity_stickyness)(entity *ent, ent_stickyness stickyness) {
439 __set_entity_stickyness(ent, stickyness);
442 /* Set has no effect for existent entities of type method. */
444 get_atomic_ent_value(entity *ent)
446 assert(ent && is_atomic_entity(ent));
447 assert(ent->variability != variability_uninitialized);
448 return skip_Id (ent->value);
452 set_atomic_ent_value(entity *ent, ir_node *val) {
453 assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
454 if (is_method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
459 /* Returns true if the the node is representable as code on
461 int is_irn_const_expression(ir_node *n) {
465 switch(get_irn_opcode(n)) {
476 if (is_irn_const_expression(get_binop_left(n)))
477 return is_irn_const_expression(get_binop_right(n));
480 return is_irn_const_expression(get_irn_n(n, 0));
489 ir_node *copy_const_value(ir_node *n) {
494 switch(get_irn_opcode(n)) {
496 nn = new_Const(m, get_Const_tarval(n)); break;
499 nn = new_SymConst(get_SymConst_symbol(n), get_SymConst_kind(n));
502 nn = new_Add(copy_const_value(get_Add_left(n)),
503 copy_const_value(get_Add_right(n)), m); break;
505 nn = new_Sub(copy_const_value(get_Sub_left(n)),
506 copy_const_value(get_Sub_right(n)), m); break;
508 nn = new_Mul(copy_const_value(get_Mul_left(n)),
509 copy_const_value(get_Mul_right(n)), m); break;
511 nn = new_And(copy_const_value(get_And_left(n)),
512 copy_const_value(get_And_right(n)), m); break;
514 nn = new_Or(copy_const_value(get_Or_left(n)),
515 copy_const_value(get_Or_right(n)), m); break;
517 nn = new_Eor(copy_const_value(get_Eor_left(n)),
518 copy_const_value(get_Eor_right(n)), m); break;
520 nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
522 nn = new_Conv(copy_const_value(get_Conv_op(n)), m); break;
524 nn = new_Unknown(m); break;
527 assert(0 && "opdope invalid or not implemented");
534 compound_graph_path *
535 new_compound_graph_path(type *tp, int length) {
536 compound_graph_path *res;
537 assert(is_type(tp) && is_compound_type(tp));
540 res = (compound_graph_path *) calloc (1, sizeof(compound_graph_path) + (length-1) * sizeof(entity *));
541 res->kind = k_ir_compound_graph_path;
544 res ->arr_indicees = (int *) calloc(length, sizeof(int));
549 free_compound_graph_path (compound_graph_path *gr) {
550 assert(gr && is_compound_graph_path(gr));
552 free(gr ->arr_indicees);
557 is_compound_graph_path(void *thing) {
558 return (get_kind(thing) == k_ir_compound_graph_path);
561 /* checks whether nodes 0..pos are correct (all lie on a path.) */
562 /* @@@ not implemented */
563 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
566 type *owner = gr->tp;
567 for (i = 0; i <= pos; i++) {
568 node = get_compound_graph_path_node(gr, i);
569 if (get_entity_owner(node) != owner) return false;
570 owner = get_entity_type(node);
572 if (pos == get_compound_graph_path_length(gr))
573 if (!is_atomic_type(owner)) return false;
578 get_compound_graph_path_length(compound_graph_path *gr) {
579 assert(gr && is_compound_graph_path(gr));
584 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
585 assert(gr && is_compound_graph_path(gr));
586 assert(pos >= 0 && pos < gr->len);
587 return gr->nodes[pos];
591 set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
592 assert(gr && is_compound_graph_path(gr));
593 assert(pos >= 0 && pos < gr->len);
594 assert(is_entity(node));
595 gr->nodes[pos] = node;
596 assert(is_proper_compound_graph_path(gr, pos));
600 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
601 assert(gr && is_compound_graph_path(gr));
602 assert(pos >= 0 && pos < gr->len);
603 return gr->arr_indicees[pos];
607 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
608 assert(gr && is_compound_graph_path(gr));
609 assert(pos >= 0 && pos < gr->len);
610 gr->arr_indicees[pos] = index;
613 /* A value of a compound entity is a pair of value and the corresponding path to a member of
616 add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
617 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
618 ARR_APP1 (ir_node *, ent->values, val);
619 ARR_APP1 (compound_graph_path *, ent->val_paths, path);
623 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
624 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
625 ent->values[pos] = val;
626 ent->val_paths[pos] = path;
630 get_compound_ent_n_values(entity *ent) {
631 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
632 return (ARR_LEN (ent->values));
636 get_compound_ent_value(entity *ent, int pos) {
637 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
638 return ent->values[pos];
641 compound_graph_path *
642 get_compound_ent_value_path(entity *ent, int pos) {
643 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
644 return ent->val_paths[pos];
648 remove_compound_ent_value(entity *ent, entity *value_ent) {
650 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
651 for (i = 0; i < (ARR_LEN (ent->val_paths)); i++) {
652 compound_graph_path *path = ent->val_paths[i];
653 if (path->nodes[path->len-1] == value_ent) {
654 for(; i < (ARR_LEN (ent->val_paths))-1; i++) {
655 ent->val_paths[i] = ent->val_paths[i+1];
656 ent->values[i] = ent->values[i+1];
658 ARR_SETLEN(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1);
659 ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1);
666 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
667 compound_graph_path *path;
668 type *owner_tp = get_entity_owner(ent);
669 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
670 path = new_compound_graph_path(owner_tp, 1);
671 path->nodes[0] = member;
672 if (is_array_type(owner_tp)) {
676 assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
677 max = get_array_lower_bound_int(owner_tp, 0) -1;
678 for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
679 int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
684 path->arr_indicees[0] = max + 1;
686 add_compound_ent_value_w_path(ent, val, path);
689 /* Copies the firm subgraph referenced by val to const_code_irg and adds
690 the node as constant initialization to ent.
691 The subgraph may not contain control flow operations.
693 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
694 ir_graph *rem = current_ir_graph;
696 assert(get_entity_variability(ent) != variability_uninitialized);
697 current_ir_graph = get_const_code_irg();
699 val = copy_const_value(val);
700 add_compound_ent_value(ent, val, member);
701 current_ir_graph = rem;
704 /* Copies the value i of the entity to current_block in current_ir_graph.
706 copy_compound_ent_value(entity *ent, int pos) {
707 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
708 return copy_const_value(ent->values[pos+1]);
712 get_compound_ent_value_member(entity *ent, int pos) {
713 compound_graph_path *path;
714 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
715 path = get_compound_ent_value_path(ent, pos);
717 return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
721 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
722 compound_graph_path *path;
723 assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
724 path = get_compound_ent_value_path(ent, pos);
725 set_compound_graph_path_node(path, 0, member);
726 set_compound_ent_value_w_path(ent, val, path, pos);
730 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
732 ir_graph *rem = current_ir_graph;
733 type *arrtp = get_entity_type(ent);
736 assert(is_array_type(arrtp));
737 assert(get_array_n_dimensions(arrtp) == 1);
738 /* One bound is sufficient, the nunmber of constant fields makes the
740 assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
741 assert(get_entity_variability(ent) != variability_uninitialized);
742 current_ir_graph = get_const_code_irg();
744 for (i = 0; i < num_vals; i++) {
745 val = new_Const(get_tarval_mode (values[i]), values[i]);
746 add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
747 set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
749 current_ir_graph = rem;
752 int get_compound_ent_value_offset_bits(entity *ent, int pos) {
753 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
755 compound_graph_path *path = get_compound_ent_value_path(ent, pos);
756 int i, path_len = get_compound_graph_path_length(path);
759 for (i = 0; i < path_len; ++i) {
760 entity *node = get_compound_graph_path_node(path, i);
761 type *node_tp = get_entity_type(node);
762 type *owner_tp = get_entity_owner(node);
763 if (is_array_type(owner_tp)) {
764 int size = get_type_size_bits(node_tp);
765 int align = get_type_alignment_bits(node_tp);
769 assert(size % align == 0);
770 /* ansonsten aufrunden */
772 offset += size * get_compound_graph_path_array_index(path, i);
774 offset += get_entity_offset_bits(node);
780 int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
781 int offset = get_compound_ent_value_offset_bits(ent, pos);
782 assert(offset % 8 == 0);
787 static void init_index(type *arr) {
791 assert(get_array_n_dimensions(arr) == 1);
793 if (has_array_lower_bound(arr, dim))
794 init = get_array_lower_bound_int(arr, 0) -1;
796 init = get_array_upper_bound_int(arr, 0) +1;
798 set_entity_link(get_array_element_entity(arr), (void *)init);
802 static int get_next_index(entity *elem_ent) {
803 type *arr = get_entity_owner(elem_ent);
807 assert(get_array_n_dimensions(arr) == 1);
809 if (has_array_lower_bound(arr, dim)) {
810 next = (int)get_entity_link(elem_ent) +1;
811 if (has_array_upper_bound(arr, dim)) {
812 int upper = get_array_upper_bound_int(arr, dim);
813 if (next == upper) next = get_array_lower_bound_int(arr, dim);
816 next = (int)get_entity_link(elem_ent) -1;
817 if (has_array_lower_bound(arr, dim)) {
818 int upper = get_array_upper_bound_int(arr, dim);
819 if (next == upper) next = get_array_upper_bound_int(arr, dim);
823 set_entity_link(elem_ent, (void *)next);
827 /* Compute the array indicees in compound graph paths of initialized entities.
829 * All arrays must have fixed lower and upper bounds. One array can
830 * have an open bound. If there are several open bounds, we do
831 * nothing. There must be initializer elements for all array
832 * elements. Uses the link field in the array element entities. The
833 * array bounds must be representable as ints.
835 * (If the bounds are not representable as ints we have to represent
836 * the indicees as firm nodes. But the still we must be able to
837 * evaluate the index against the upper bound.)
839 void compute_compound_ent_array_indicees(entity *ent) {
840 type *tp = get_entity_type(ent);
842 entity *unknown_bound_entity = NULL;
844 if (!is_compound_type(tp) ||
845 (ent->variability == variability_uninitialized)) return ;
847 n_vals = get_compound_ent_n_values(ent);
848 if (n_vals == 0) return;
850 /* We can not compute the indicees if there is more than one array
851 with an unknown bound. For this remember the first entity that
852 represents such an array. It could be ent. */
853 if (is_array_type(tp)) {
854 assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
856 if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
857 unknown_bound_entity = ent;
860 /* Initialize the entity links to lower bound -1 and test all path elements
862 for (i = 0; i < n_vals; ++i) {
863 compound_graph_path *path = get_compound_ent_value_path(ent, i);
864 int j, path_len = get_compound_graph_path_length(path);
865 for (j = 0; j < path_len; ++j) {
866 entity *node = get_compound_graph_path_node(path, j);
867 type *elem_tp = get_entity_type(node);
869 if (is_array_type(elem_tp)) {
870 assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
872 if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
873 if (!unknown_bound_entity) unknown_bound_entity = node;
874 if (node != unknown_bound_entity) return;
882 /* Finally compute the indicees ... */
883 for (i = 0; i < n_vals; ++i) {
884 compound_graph_path *path = get_compound_ent_value_path(ent, i);
885 int j, path_len = get_compound_graph_path_length(path);
886 for (j = 0; j < path_len; ++j) {
887 entity *node = get_compound_graph_path_node(path, j);
888 type *owner_tp = get_entity_owner(node);
889 if (is_array_type(owner_tp))
890 set_compound_graph_path_array_index (path, j, get_next_index(node));
897 static int *resize (int *buf, int new_size) {
898 int *new_buf = (int *)calloc(new_size, 4);
899 memcpy(new_buf, buf, new_size>1);
904 /* We sort the elements by placing them at their bit offset in an
905 array where each entry represents one bit called permutation. In
906 fact, we do not place the values themselves, as we would have to
907 copy two things, the value and the path. We only remember the
908 position in the old order. Each value should have a distinct
909 position in the permutation.
911 A second iteration now permutes the actual elements into two
913 void sort_compound_ent_values(entity *ent) {
914 assert(get_type_state(get_entity_type(ent)) == layout_fixed);
916 type *tp = get_entity_type(ent);
917 int i, n_vals = get_compound_ent_n_values(ent);
918 int tp_size = get_type_size_bits(tp);
922 if (!is_compound_type(tp) ||
923 (ent->variability == variability_uninitialized) ||
924 (get_type_state(tp) != layout_fixed) ||
925 (n_vals == 0) ) return;
927 /* estimated upper bound for size. Better: use flexible array ... */
928 size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
929 permutation = (int *)calloc(size, 4);
930 for (i = 0; i < n_vals; ++i) {
931 int pos = get_compound_ent_value_offset_bits(ent, i);
932 while (pos >= size) {
934 permutation = resize(permutation, size);
937 assert(permutation[pos] == 0 && "two values with the same offset");
938 permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
939 So inc all entries by one. */
940 //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
944 ir_node **my_values = NEW_ARR_F(ir_node *, n_vals);
945 compound_graph_path **my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
946 for (i = 0; i < size; ++i) {
947 int pos = permutation[i];
949 //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next);
950 assert(next < n_vals);
951 pos--; /* We increased the pos by one */
952 my_values[next] = get_compound_ent_value (ent, pos);
953 my_paths [next] = get_compound_ent_value_path(ent, pos);
959 DEL_ARR_F(ent->values);
960 ent->values = my_values;
961 DEL_ARR_F(ent->val_paths);
962 ent->val_paths = my_paths;
966 (get_entity_offset_bytes)(entity *ent) {
967 return __get_entity_offset_bytes(ent);
971 (get_entity_offset_bits)(entity *ent) {
972 return __get_entity_offset_bits(ent);
976 (set_entity_offset_bytes)(entity *ent, int offset) {
977 __set_entity_offset_bytes(ent, offset);
981 (set_entity_offset_bits)(entity *ent, int offset) {
982 __set_entity_offset_bits(ent, offset);
986 add_entity_overwrites(entity *ent, entity *overwritten) {
987 assert(ent && is_class_type(get_entity_owner(ent)));
988 ARR_APP1(entity *, ent->overwrites, overwritten);
989 ARR_APP1(entity *, overwritten->overwrittenby, ent);
993 get_entity_n_overwrites(entity *ent) {
994 assert(ent && is_class_type(get_entity_owner(ent)));
995 return (ARR_LEN(ent->overwrites));
999 get_entity_overwrites_index(entity *ent, entity *overwritten) {
1001 assert(ent && is_class_type(get_entity_owner(ent)));
1002 for (i = 0; i < get_entity_n_overwrites(ent); i++)
1003 if (get_entity_overwrites(ent, i) == overwritten)
1009 get_entity_overwrites (entity *ent, int pos) {
1010 assert(ent && is_class_type(get_entity_owner(ent)));
1011 assert(pos < get_entity_n_overwrites(ent));
1012 return ent->overwrites[pos];
1016 set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
1017 assert(ent && is_class_type(get_entity_owner(ent)));
1018 assert(pos < get_entity_n_overwrites(ent));
1019 ent->overwrites[pos] = overwritten;
1023 remove_entity_overwrites(entity *ent, entity *overwritten) {
1025 assert(ent && is_class_type(get_entity_owner(ent)));
1026 for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1027 if (ent->overwrites[i] == overwritten) {
1028 for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1029 ent->overwrites[i] = ent->overwrites[i+1];
1030 ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1036 add_entity_overwrittenby (entity *ent, entity *overwrites) {
1037 assert(ent && is_class_type(get_entity_owner(ent)));
1038 add_entity_overwrites(overwrites, ent);
1042 get_entity_n_overwrittenby (entity *ent) {
1043 assert(ent && is_class_type(get_entity_owner(ent)));
1044 return (ARR_LEN (ent->overwrittenby));
1048 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1050 assert(ent && is_class_type(get_entity_owner(ent)));
1051 for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1052 if (get_entity_overwrittenby(ent, i) == overwrites)
1058 get_entity_overwrittenby (entity *ent, int pos) {
1059 assert(ent && is_class_type(get_entity_owner(ent)));
1060 assert(pos < get_entity_n_overwrittenby(ent));
1061 return ent->overwrittenby[pos];
1065 set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
1066 assert(ent && is_class_type(get_entity_owner(ent)));
1067 assert(pos < get_entity_n_overwrittenby(ent));
1068 ent->overwrittenby[pos] = overwrites;
1071 void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1073 assert(ent && is_class_type(get_entity_owner(ent)));
1074 for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1075 if (ent->overwrittenby[i] == overwrites) {
1076 for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1077 ent->overwrittenby[i] = ent->overwrittenby[i+1];
1078 ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1083 /* A link to store intermediate information */
1085 (get_entity_link)(entity *ent) {
1086 return __get_entity_link(ent);
1090 (set_entity_link)(entity *ent, void *l) {
1091 __set_entity_link(ent, l);
1095 (get_entity_irg)(entity *ent) {
1096 return __get_entity_irg(ent);
1100 set_entity_irg(entity *ent, ir_graph *irg) {
1101 assert(ent && is_method_type(get_entity_type(ent)));
1102 /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1103 * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1104 * aber erhalten bleiben soll. */
1106 assert((irg && ent->peculiarity == peculiarity_existent) ||
1107 (!irg && ent->peculiarity == peculiarity_description) ||
1108 (!irg && ent->peculiarity == peculiarity_inherited));
1113 (is_entity)(void *thing) {
1114 return __is_entity(thing);
1117 int is_atomic_entity(entity *ent) {
1118 type* t = get_entity_type(ent);
1119 assert(ent && ent->kind == k_entity);
1120 return (is_primitive_type(t) || is_pointer_type(t) ||
1121 is_enumeration_type(t) || is_method_type(t));
1124 int is_compound_entity(entity *ent) {
1125 type* t = get_entity_type(ent);
1126 assert(ent && ent->kind == k_entity);
1127 return (is_class_type(t) || is_struct_type(t) ||
1128 is_array_type(t) || is_union_type(t));
1132 * @todo not implemnted!!! */
1133 bool equal_entity(entity *ent1, entity *ent2) {
1134 fprintf(stderr, " calling unimplemented equal entity!!! \n");
1139 unsigned long get_entity_visited(entity *ent) {
1140 assert(ent && ent->kind == k_entity);
1143 void set_entity_visited(entity *ent, unsigned long num) {
1144 assert(ent && ent->kind == k_entity);
1147 /* Sets visited field in entity to entity_visited. */
1148 void mark_entity_visited(entity *ent) {
1149 assert(ent && ent->kind == k_entity);
1150 ent->visit = type_visited;
1154 bool entity_visited(entity *ent) {
1155 assert(ent && ent->kind == k_entity);
1156 return get_entity_visited(ent) >= type_visited;
1159 bool entity_not_visited(entity *ent) {
1160 assert(ent && ent->kind == k_entity);
1161 return get_entity_visited(ent) < type_visited;
1164 /* Need two routines because I want to assert the result. */
1165 static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) {
1166 int i, n_overwrittenby;
1169 if (get_entity_owner(static_ent) == dynamic_class) return static_ent;
1171 n_overwrittenby = get_entity_n_overwrittenby(static_ent);
1172 for (i = 0; i < n_overwrittenby; ++i) {
1173 res = resolve_ent_polymorphy2(dynamic_class, get_entity_overwrittenby(static_ent, i));
1180 /** Resolve polymorphy in the inheritance relation.
1182 * Returns the dynamically referenced entity if the static entity and the
1183 * dynamic type are given.
1184 * Search downwards in overwritten tree. */
1185 entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent) {
1187 assert(static_ent && static_ent->kind == k_entity);
1189 res = resolve_ent_polymorphy2(dynamic_class, static_ent);
1192 printf(" Could not find entity "); DDME(static_ent);
1193 printf(" in "); DDMT(dynamic_class);
1195 dump_entity(static_ent);
1196 dump_type(get_entity_owner(static_ent));
1197 dump_type(dynamic_class);