1/* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
4
5This file is part of GNU CC.
6
7GNU CC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
--- 12 unchanged lines hidden (view full) ---
23#include "system.h"
24#include "obstack.h"
25#include "tree.h"
26#include "cp-tree.h"
27#include "flags.h"
28#include "rtl.h"
29#include "toplev.h"
30
31#ifdef __STDC__
32#include <stdarg.h>
33#else
34#include <varargs.h>
35#endif
36
37extern void compiler_error ();
38
39static tree get_identifier_list PROTO((tree));
40static tree bot_manip PROTO((tree));
41static tree perm_manip PROTO((tree));
42static tree build_cplus_array_type_1 PROTO((tree, tree));
43static void list_hash_add PROTO((int, tree));
44static int list_hash PROTO((tree, tree, tree));
45static tree list_hash_lookup PROTO((int, int, int, int, tree, tree,
46 tree));
47static void propagate_binfo_offsets PROTO((tree, tree));
48static void unshare_base_binfos PROTO((tree));
49static int avoid_overlap PROTO((tree, tree));
50static int equal_functions PROTO((tree, tree));
51
52#define CEIL(x,y) (((x) + (y) - 1) / (y))
53
54/* Return nonzero if REF is an lvalue valid for this language.
55 Lvalues can be assigned, unless they have TREE_READONLY.
56 Lvalues can have their address taken, unless they have DECL_REGISTER. */
57
58int
59real_lvalue_p (ref)
60 tree ref;
61{
62 if (! language_lvalue_valid (ref))
63 return 0;
64
65 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
66 return 1;
67
68 if (ref == current_class_ptr && flag_this_is_variable <= 0)
69 return 0;
70
71 switch (TREE_CODE (ref))
72 {
73 /* preincrements and predecrements are valid lvals, provided
74 what they refer to are valid lvals. */
75 case PREINCREMENT_EXPR:
76 case PREDECREMENT_EXPR:
77 case COMPONENT_REF:
78 case SAVE_EXPR:
79 case UNSAVE_EXPR:
80 case TRY_CATCH_EXPR:
81 case WITH_CLEANUP_EXPR:
82 return real_lvalue_p (TREE_OPERAND (ref, 0));
83
84 case STRING_CST:
85 return 1;
86
87 case VAR_DECL:
88 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
89 && DECL_LANG_SPECIFIC (ref)
90 && DECL_IN_AGGR_P (ref))
91 return 0;
92 case INDIRECT_REF:
93 case ARRAY_REF:
94 case PARM_DECL:
95 case RESULT_DECL:
96 case ERROR_MARK:
97 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
98 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
99 return 1;
100 break;
101
102 /* A currently unresolved scope ref. */
103 case SCOPE_REF:
104 my_friendly_abort (103);
105 case OFFSET_REF:
106 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
107 return 1;
108 return real_lvalue_p (TREE_OPERAND (ref, 0))
109 && real_lvalue_p (TREE_OPERAND (ref, 1));
110 break;
111
112 case COND_EXPR:
113 return (real_lvalue_p (TREE_OPERAND (ref, 1))
114 && real_lvalue_p (TREE_OPERAND (ref, 2)));
115
116 case MODIFY_EXPR:
117 return 1;
118
119 case COMPOUND_EXPR:
120 return real_lvalue_p (TREE_OPERAND (ref, 1));
121
122 case MAX_EXPR:
123 case MIN_EXPR:
124 return (real_lvalue_p (TREE_OPERAND (ref, 0))
125 && real_lvalue_p (TREE_OPERAND (ref, 1)));
126
127 default:
128 break;
129 }
130
131 return 0;
132}
133
134/* This differs from real_lvalue_p in that class rvalues are considered
135 lvalues. */
136int
137lvalue_p (ref)
138 tree ref;
139{
140 if (! language_lvalue_valid (ref))
141 return 0;
142
143 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
144 return 1;
145
146 if (ref == current_class_ptr && flag_this_is_variable <= 0)
147 return 0;
148
149 switch (TREE_CODE (ref))
150 {
151 /* preincrements and predecrements are valid lvals, provided
152 what they refer to are valid lvals. */
153 case PREINCREMENT_EXPR:
154 case PREDECREMENT_EXPR:
155 case REALPART_EXPR:
156 case IMAGPART_EXPR:
157 case COMPONENT_REF:
158 case SAVE_EXPR:
159 case UNSAVE_EXPR:
160 case TRY_CATCH_EXPR:
161 case WITH_CLEANUP_EXPR:
162 return lvalue_p (TREE_OPERAND (ref, 0));
163
164 case STRING_CST:
165 return 1;
166
167 case VAR_DECL:
168 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
169 && DECL_LANG_SPECIFIC (ref)
170 && DECL_IN_AGGR_P (ref))
171 return 0;
172 case INDIRECT_REF:
173 case ARRAY_REF:
174 case PARM_DECL:
175 case RESULT_DECL:
176 case ERROR_MARK:
177 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
178 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
179 return 1;
180 break;
181
182 case TARGET_EXPR:
183 return 1;
184
185 case CALL_EXPR:
186 if (IS_AGGR_TYPE (TREE_TYPE (ref)))
187 return 1;
188 break;
189
190 /* A currently unresolved scope ref. */
191 case SCOPE_REF:
192 my_friendly_abort (103);
193 case OFFSET_REF:
194 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
195 return 1;
196 return lvalue_p (TREE_OPERAND (ref, 0))
197 && lvalue_p (TREE_OPERAND (ref, 1));
198 break;
199
200 case COND_EXPR:
201 return (lvalue_p (TREE_OPERAND (ref, 1))
202 && lvalue_p (TREE_OPERAND (ref, 2)));
203
204 case MODIFY_EXPR:
205 return 1;
206
207 case COMPOUND_EXPR:
208 return lvalue_p (TREE_OPERAND (ref, 1));
209
210 case MAX_EXPR:
211 case MIN_EXPR:
212 return (lvalue_p (TREE_OPERAND (ref, 0))
213 && lvalue_p (TREE_OPERAND (ref, 1)));
214
215 default:
216 break;
217 }
218
219 return 0;
220}
221
222/* Return nonzero if REF is an lvalue valid for this language;
223 otherwise, print an error message and return zero. */
224
225int
226lvalue_or_else (ref, string)
227 tree ref;
228 char *string;
229{
230 int win = lvalue_p (ref);
231 if (! win)
232 error ("non-lvalue in %s", string);
233 return win;
234}
235
236/* INIT is a CALL_EXPR which needs info about its target.
--- 7 unchanged lines hidden (view full) ---
244build_cplus_new (type, init)
245 tree type;
246 tree init;
247{
248 tree slot;
249 tree rval;
250
251 if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
252 return init;
253
254 slot = build (VAR_DECL, type);
255 DECL_ARTIFICIAL (slot) = 1;
256 layout_decl (slot, 0);
257 rval = build (AGGR_INIT_EXPR, type,
258 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
259 TREE_SIDE_EFFECTS (rval) = 1;
260 rval = build (TARGET_EXPR, type, slot, rval, NULL_TREE, NULL_TREE);
--- 165 unchanged lines hidden (view full) ---
426 int hashcode;
427
428 /* Make a node of the sort we want. */
429 t = make_node (METHOD_TYPE);
430
431 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
432 TREE_TYPE (t) = rettype;
433 if (IS_SIGNATURE (basetype))
434 ptype = build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype),
435 TYPE_READONLY (basetype),
436 TYPE_VOLATILE (basetype));
437 else
438 ptype = build_pointer_type (basetype);
439
440 /* The actual arglist for this function includes a "hidden" argument
441 which is "this". Put it into the list of argument types. */
442
443 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
444 TYPE_ARG_TYPES (t) = argtypes;
--- 23 unchanged lines hidden (view full) ---
468 make this permanent too. */
469 if (TREE_PERMANENT (elt_type)
470 && (index_type == 0 || TREE_PERMANENT (index_type)))
471 {
472 current_obstack = &permanent_obstack;
473 saveable_obstack = &permanent_obstack;
474 }
475
476 if (processing_template_decl
477 || uses_template_parms (index_type))
478 {
479 t = make_node (ARRAY_TYPE);
480 TREE_TYPE (t) = elt_type;
481 TYPE_DOMAIN (t) = index_type;
482 }
483 else
484 t = build_array_type (elt_type, index_type);
--- 8 unchanged lines hidden (view full) ---
493}
494
495tree
496build_cplus_array_type (elt_type, index_type)
497 tree elt_type;
498 tree index_type;
499{
500 tree t;
501 int constp = TYPE_READONLY (elt_type);
502 int volatilep = TYPE_VOLATILE (elt_type);
503 elt_type = TYPE_MAIN_VARIANT (elt_type);
504
505 t = build_cplus_array_type_1 (elt_type, index_type);
506
507 if (constp || volatilep)
508 t = cp_build_type_variant (t, constp, volatilep);
509
510 return t;
511}
512
513/* Make a variant type in the proper way for C/C++, propagating qualifiers
514 down to the element type of an array. */
515
516tree
517cp_build_type_variant (type, constp, volatilep)
518 tree type;
519 int constp, volatilep;
520{
521 if (type == error_mark_node)
522 return type;
523
524 if (TREE_CODE (type) == ARRAY_TYPE)
525 {
526 tree real_main_variant = TYPE_MAIN_VARIANT (type);
527
528 push_obstacks (TYPE_OBSTACK (real_main_variant),
529 TYPE_OBSTACK (real_main_variant));
530 type = build_cplus_array_type_1 (cp_build_type_variant
531 (TREE_TYPE (type), constp, volatilep),
532 TYPE_DOMAIN (type));
533
534 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
535 make a copy. (TYPE might have come from the hash table and
536 REAL_MAIN_VARIANT might be in some function's obstack.) */
537
538 if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant))
539 {
540 type = copy_node (type);
541 TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0;
542 }
543
544 TYPE_MAIN_VARIANT (type) = real_main_variant;
545 pop_obstacks ();
546 return type;
547 }
548 return build_type_variant (type, constp, volatilep);
549}
550
551/* Returns the canonical version of TYPE. In other words, if TYPE is
552 a typedef, returns the underlying type. The cv-qualification of
553 the type returned matches the type input; they will always be
554 compatible types. */
555
556tree
557canonical_type_variant (t)
558 tree t;
559{
560 int constp, volatilep;
561 if (TREE_CODE (t) == ARRAY_TYPE)
562 {
563 constp = TYPE_READONLY (TREE_TYPE (t));
564 volatilep = TYPE_VOLATILE (TREE_TYPE (t));
565 }
566 else
567 {
568 constp = TYPE_READONLY (t);
569 volatilep = TYPE_VOLATILE (t);
570 }
571 return cp_build_type_variant (TYPE_MAIN_VARIANT (t), constp, volatilep);
572}
573
574/* Add OFFSET to all base types of T.
575
576 OFFSET, which is a type offset, is number of bytes.
577
578 Note that we don't have to worry about having two paths to the
579 same base type, since this type owns its association list. */
--- 33 unchanged lines hidden (view full) ---
613 BINFO_OFFSET (base_binfo) = offset;
614 else
615 BINFO_OFFSET (base_binfo)
616 = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
617#else
618 BINFO_OFFSET (base_binfo) = offset;
619#endif
620
621 unshare_base_binfos (base_binfo);
622
623 /* Go to our next class that counts for offset propagation. */
624 i = j;
625 if (i < n_baselinks)
626 offset = size_binop (PLUS_EXPR, offset, delta);
627 }
628 }
629}
630
631/* Makes new binfos for the indirect bases under BASE_BINFO, and updates
632 BINFO_OFFSET for them and their bases. */
633
634static void
635unshare_base_binfos (base_binfo)
636 tree base_binfo;
637{
638 if (BINFO_BASETYPES (base_binfo))
639 {
640 tree base_binfos = BINFO_BASETYPES (base_binfo);
641 tree chain = NULL_TREE;
642 int j;
643
644 /* Now unshare the structure beneath BASE_BINFO. */
645 for (j = TREE_VEC_LENGTH (base_binfos)-1;
646 j >= 0; j--)
647 {
648 tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
649 if (! TREE_VIA_VIRTUAL (base_base_binfo))
650 TREE_VEC_ELT (base_binfos, j)
651 = make_binfo (BINFO_OFFSET (base_base_binfo),
652 base_base_binfo,
653 BINFO_VTABLE (base_base_binfo),
654 BINFO_VIRTUALS (base_base_binfo),
655 chain);
656 chain = TREE_VEC_ELT (base_binfos, j);
657 TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
658 TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
659 BINFO_INHERITANCE_CHAIN (chain) = base_binfo;
660 }
661
662 /* Completely unshare potentially shared data, and
663 update what is ours. */
664 propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
665 }
666}
667
668/* Finish the work of layout_record, now taking virtual bases into account.
669 Also compute the actual offsets that our base classes will have.
670 This must be performed after the fields are laid out, since virtual
671 baseclasses must lay down at the end of the record.
672
673 Returns the maximum number of virtual functions any of the
674 baseclasses provide. */
675
676int
677layout_basetypes (rec, max)
678 tree rec;
679 int max;
680{
681 tree binfos = TYPE_BINFO_BASETYPES (rec);
682 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
683
684 /* Get all the virtual base types that this type uses.
685 The TREE_VALUE slot holds the virtual baseclass type. */
686 tree vbase_types = get_vbase_types (rec);
687
688 unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
689 unsigned int desired_align;
690
691 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
692 register unsigned int const_size = 0;
693 unsigned int nonvirtual_const_size;
694
695#ifdef STRUCTURE_SIZE_BOUNDARY
696 /* Packed structures don't need to have minimum size. */
697 if (! TYPE_PACKED (rec))
698 record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY);
699#endif
700
701 CLASSTYPE_VBASECLASSES (rec) = vbase_types;
702
703 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST, 19970302);
704 const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
705
706 nonvirtual_const_size = const_size;
707
708 while (vbase_types)
709 {
--- 49 unchanged lines hidden (view full) ---
759 register tree base_binfo = TREE_VEC_ELT (binfos, i);
760 register tree basetype = BINFO_TYPE (base_binfo);
761 tree field = TYPE_FIELDS (rec);
762
763 if (TREE_VIA_VIRTUAL (base_binfo))
764 continue;
765
766 my_friendly_assert (TREE_TYPE (field) == basetype, 23897);
767 BINFO_OFFSET (base_binfo)
768 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)),
769 BITS_PER_UNIT));
770 unshare_base_binfos (base_binfo);
771 TYPE_FIELDS (rec) = TREE_CHAIN (field);
772 }
773
774 for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
775 vbase_types = TREE_CHAIN (vbase_types))
776 {
777 BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec);
778 unshare_base_binfos (vbase_types);
779 }
780
781 return max;
782}
783
784/* If the empty base field in DECL overlaps with a base of the same type in
785 NEWDECL, which is either another base field or the first data field of
786 the class, pad the base just before NEWDECL and return 1. Otherwise,
--- 59 unchanged lines hidden (view full) ---
846 {
847 /* Brain damage for backwards compatibility. For no good reason,
848 the old layout_basetypes made every base at least as large as
849 the alignment for the bases up to that point, gratuitously
850 wasting space. So we do the same thing here. */
851 base_align = MAX (base_align, DECL_ALIGN (decl));
852 DECL_SIZE (decl)
853 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
854 base_align));
855 }
856 else if (DECL_SIZE (decl) == integer_zero_node)
857 saw_empty = 1;
858 }
859
860 /* Reverse the list of fields so we allocate the bases in the proper
861 order. */
862 base_decls = nreverse (base_decls);
--- 57 unchanged lines hidden (view full) ---
920 continue;
921
922 /* All basetypes are recorded in the association list of the
923 derived type. */
924
925 if (TREE_VIA_VIRTUAL (base_binfo))
926 {
927 int j;
928 char *name = (char *)alloca (TYPE_NAME_LENGTH (basetype)
929 + sizeof (VBASE_NAME) + 1);
930
931 /* The offset for a virtual base class is only used in computing
932 virtual function tables and for initializing virtual base
933 pointers. It is built once `get_vbase_types' is called. */
934
935 /* If this basetype can come from another vbase pointer
936 without an additional indirection, we will share
937 that pointer. If an indirection is involved, we
938 make our own pointer. */
939 for (j = 0; j < n_baseclasses; j++)
940 {
941 tree other_base_binfo = TREE_VEC_ELT (binfos, j);
942 if (! TREE_VIA_VIRTUAL (other_base_binfo)
943 && binfo_member (basetype,
944 CLASSTYPE_VBASECLASSES (BINFO_TYPE
945 (other_base_binfo))
946 ))
947 goto got_it;
948 }
949 sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (basetype));
950 decl = build_lang_field_decl (FIELD_DECL, get_identifier (name),
951 build_pointer_type (basetype));
952 /* If you change any of the below, take a look at all the
953 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
954 them too. */
955 DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
956 DECL_VIRTUAL_P (decl) = 1;
957 DECL_ARTIFICIAL (decl) = 1;
--- 61 unchanged lines hidden (view full) ---
1019 hashcode += 1009;
1020 return hashcode;
1021}
1022
1023/* Look in the type hash table for a type isomorphic to TYPE.
1024 If one is found, return it. Otherwise return 0. */
1025
1026static tree
1027list_hash_lookup (hashcode, via_public, via_protected, via_virtual,
1028 purpose, value, chain)
1029 int hashcode, via_public, via_virtual, via_protected;
1030 tree purpose, value, chain;
1031{
1032 register struct list_hash *h;
1033
1034 for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
1035 if (h->hashcode == hashcode
1036 && TREE_VIA_VIRTUAL (h->list) == via_virtual
1037 && TREE_VIA_PUBLIC (h->list) == via_public
1038 && TREE_VIA_PROTECTED (h->list) == via_protected
1039 && TREE_PURPOSE (h->list) == purpose
1040 && TREE_VALUE (h->list) == value
1041 && TREE_CHAIN (h->list) == chain)
1042 return h->list;
1043 return 0;
1044}
1045
1046/* Add an entry to the list-hash-table
--- 8 unchanged lines hidden (view full) ---
1055
1056 h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
1057 h->hashcode = hashcode;
1058 h->list = list;
1059 h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
1060 list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
1061}
1062
1063/* Given TYPE, and HASHCODE its hash code, return the canonical
1064 object for an identical list if one already exists.
1065 Otherwise, return TYPE, and record it as the canonical object
1066 if it is a permanent object.
1067
1068 To use this function, first create a list of the sort you want.
1069 Then compute its hash code from the fields of the list that
1070 make it different from other similar lists.
1071 Then call this function and use the value.
1072 This function frees the list you pass in if it is a duplicate. */
1073
1074/* Set to 1 to debug without canonicalization. Never set by program. */
1075
1076static int debug_no_list_hash = 0;
1077
1078tree
1079hash_tree_cons (via_public, via_virtual, via_protected, purpose, value, chain)
1080 int via_public, via_virtual, via_protected;
1081 tree purpose, value, chain;
1082{
1083 struct obstack *ambient_obstack = current_obstack;
1084 tree t;
1085 int hashcode = 0;
1086
1087 if (! debug_no_list_hash)
1088 {
1089 hashcode = list_hash (purpose, value, chain);
1090 t = list_hash_lookup (hashcode, via_public, via_protected, via_virtual,
1091 purpose, value, chain);
1092 if (t)
1093 return t;
1094 }
1095
1096 current_obstack = &class_obstack;
1097
1098 t = tree_cons (purpose, value, chain);
1099 TREE_VIA_PUBLIC (t) = via_public;
1100 TREE_VIA_PROTECTED (t) = via_protected;
1101 TREE_VIA_VIRTUAL (t) = via_virtual;
1102
1103 /* If this is a new list, record it for later reuse. */
1104 if (! debug_no_list_hash)
1105 list_hash_add (hashcode, t);
1106
1107 current_obstack = ambient_obstack;
1108 return t;
1109}
1110
1111/* Constructor for hashed lists. */
1112
1113tree
1114hash_tree_chain (value, chain)
1115 tree value, chain;
1116{
1117 return hash_tree_cons (0, 0, 0, NULL_TREE, value, chain);
1118}
1119
1120/* Similar, but used for concatenating two lists. */
1121
1122tree
1123hash_chainon (list1, list2)
1124 tree list1, list2;
1125{
1126 if (list2 == 0)
1127 return list1;
1128 if (list1 == 0)
1129 return list2;
1130 if (TREE_CHAIN (list1) == NULL_TREE)
1131 return hash_tree_chain (TREE_VALUE (list1), list2);
1132 return hash_tree_chain (TREE_VALUE (list1),
1133 hash_chainon (TREE_CHAIN (list1), list2));
1134}
1135
1136static tree
1137get_identifier_list (value)
1138 tree value;
1139{
1140 tree list = IDENTIFIER_AS_LIST (value);
1141 if (list != NULL_TREE
1142 && (TREE_CODE (list) != TREE_LIST
1143 || TREE_VALUE (list) != value))
1144 list = NULL_TREE;
1145 else if (IDENTIFIER_HAS_TYPE_VALUE (value)
1146 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE
1147 && IDENTIFIER_TYPE_VALUE (value)
1148 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value)))
1149 {
1150 tree type = IDENTIFIER_TYPE_VALUE (value);
1151
1152 if (TYPE_PTRMEMFUNC_P (type))
1153 list = NULL_TREE;
1154 else if (type == current_class_type)
1155 /* Don't mess up the constructor name. */
1156 list = tree_cons (NULL_TREE, value, NULL_TREE);
1157 else
1158 {
1159 if (! CLASSTYPE_ID_AS_LIST (type))
1160 CLASSTYPE_ID_AS_LIST (type)
1161 = perm_tree_cons (NULL_TREE, TYPE_IDENTIFIER (type), NULL_TREE);
1162 list = CLASSTYPE_ID_AS_LIST (type);
1163 }
1164 }
1165 return list;
1166}
1167
1168tree
1169get_decl_list (value)
1170 tree value;
1171{
1172 tree list = NULL_TREE;
1173
1174 if (TREE_CODE (value) == IDENTIFIER_NODE)
1175 list = get_identifier_list (value);
1176 else if (TREE_CODE (value) == RECORD_TYPE
1177 && TYPE_LANG_SPECIFIC (value)
1178 && value == TYPE_MAIN_VARIANT (value))
1179 list = CLASSTYPE_AS_LIST (value);
1180
1181 if (list != NULL_TREE)
1182 {
1183 my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 301);
1184 return list;
1185 }
1186
1187 return build_decl_list (NULL_TREE, value);
1188}
1189
1190/* Build an association between TYPE and some parameters:
1191
1192 OFFSET is the offset added to `this' to convert it to a pointer
1193 of type `TYPE *'
1194
1195 BINFO is the base binfo to use, if we are deriving from one. This
1196 is necessary, as we want specialized parent binfos from base
1197 classes, so that the VTABLE_NAMEs of bases are for the most derived
1198 type, instead of the simple type.
1199
1200 VTABLE is the virtual function table with which to initialize
1201 sub-objects of type TYPE.
1202
1203 VIRTUALS are the virtual functions sitting in VTABLE.
1204
1205 CHAIN are more associations we must retain. */
1206
1207tree
1208make_binfo (offset, binfo, vtable, virtuals, chain)
1209 tree offset, binfo;
1210 tree vtable, virtuals;
1211 tree chain;
1212{
1213 tree new_binfo = make_tree_vec (7);
1214 tree type;
1215
1216 if (TREE_CODE (binfo) == TREE_VEC)
1217 type = BINFO_TYPE (binfo);
1218 else
1219 {
1220 type = binfo;
1221 binfo = TYPE_BINFO (binfo);
1222 }
1223
1224 TREE_CHAIN (new_binfo) = chain;
1225 if (chain)
1226 TREE_USED (new_binfo) = TREE_USED (chain);
1227
1228 TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
1229 BINFO_OFFSET (new_binfo) = offset;
1230 BINFO_VTABLE (new_binfo) = vtable;
1231 BINFO_VIRTUALS (new_binfo) = virtuals;
1232 BINFO_VPTR_FIELD (new_binfo) = NULL_TREE;
1233
1234 if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE)
1235 BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
--- 12 unchanged lines hidden (view full) ---
1248 TYPE_NAME_STRING (elem));
1249 if (elem == type)
1250 return TYPE_BINFO (type);
1251 if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1252 return type;
1253 return get_binfo (elem, type, 0);
1254}
1255
1256tree
1257reverse_path (path)
1258 tree path;
1259{
1260 register tree prev = 0, tmp, next;
1261 for (tmp = path; tmp; tmp = next)
1262 {
1263 next = BINFO_INHERITANCE_CHAIN (tmp);
1264 BINFO_INHERITANCE_CHAIN (tmp) = prev;
1265 prev = tmp;
1266 }
1267 return prev;
1268}
1269
1270void
1271debug_binfo (elem)
1272 tree elem;
1273{
1274 unsigned HOST_WIDE_INT n;
--- 6 unchanged lines hidden (view full) ---
1281 debug_tree (BINFO_TYPE (elem));
1282 if (BINFO_VTABLE (elem))
1283 fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1284 else
1285 fprintf (stderr, "no vtable decl yet\n");
1286 fprintf (stderr, "virtuals:\n");
1287 virtuals = BINFO_VIRTUALS (elem);
1288
1289 n = skip_rtti_stuff (&virtuals);
1290
1291 while (virtuals)
1292 {
1293 tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
1294 fprintf (stderr, "%s [%ld =? %ld]\n",
1295 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1296 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1297 ++n;
--- 37 unchanged lines hidden (view full) ---
1335 my_friendly_abort (359);
1336 return 0;
1337}
1338
1339int
1340is_overloaded_fn (x)
1341 tree x;
1342{
1343 /* XXX A baselink is also considered an overloaded function.
1344 As is a placeholder from push_class_decls. */
1345 if (TREE_CODE (x) == TREE_LIST)
1346 {
1347 my_friendly_assert (TREE_CODE (TREE_PURPOSE (x)) == TREE_VEC
1348 || TREE_CODE (TREE_PURPOSE (x)) == IDENTIFIER_NODE,
1349 388);
1350 x = TREE_VALUE (x);
1351 }
1352 return (TREE_CODE (x) == FUNCTION_DECL
1353 || TREE_CODE (x) == TEMPLATE_ID_EXPR
1354 || DECL_FUNCTION_TEMPLATE_P (x)
1355 || TREE_CODE (x) == OVERLOAD);
1356}
1357
1358int
1359really_overloaded_fn (x)
1360 tree x;
1361{
1362 /* A baselink is also considered an overloaded function.
1363 This might also be an ambiguous class member. */
1364 if (TREE_CODE (x) == TREE_LIST)
1365 x = TREE_VALUE (x);
1366 return (TREE_CODE (x) == OVERLOAD
1367 && (TREE_CHAIN (x) != NULL_TREE
1368 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1369}
1370
1371tree
1372get_first_fn (from)
1373 tree from;
1374{
1375 my_friendly_assert (is_overloaded_fn (from), 9);
1376 /* A baselink is also considered an overloaded function. */
1377 if (TREE_CODE (from) == TREE_LIST)
1378 from = TREE_VALUE (from);
1379 return OVL_CURRENT (from);
1380}
1381
1382/* Return a new OVL node, concatenating it with the old one. */
1383
1384tree
1385ovl_cons (decl, chain)
1386 tree decl;
1387 tree chain;
1388{
1389 tree result = make_node (OVERLOAD);
--- 22 unchanged lines hidden (view full) ---
1412/* Build a new overloaded function. If this is the first one,
1413 just return it; otherwise, ovl_cons the _DECLs */
1414
1415tree
1416build_overload (decl, chain)
1417 tree decl;
1418 tree chain;
1419{
1420 if (!chain)
1421 return decl;
1422 if (TREE_CODE (chain) != OVERLOAD)
1423 chain = ovl_cons (chain, NULL_TREE);
1424 return ovl_cons (decl, chain);
1425}
1426
1427/* Returns true iff functions are equivalent. Equivalent functions are
1428 not identical only if one is a function-local extern function.
1429 This assumes that function-locals don't have TREE_PERMANENT. */
1430
--- 82 unchanged lines hidden (view full) ---
1513 listed in RAISES. */
1514
1515tree
1516build_exception_variant (type, raises)
1517 tree type;
1518 tree raises;
1519{
1520 tree v = TYPE_MAIN_VARIANT (type);
1521 int constp = TYPE_READONLY (type);
1522 int volatilep = TYPE_VOLATILE (type);
1523
1524 for (; v; v = TYPE_NEXT_VARIANT (v))
1525 {
1526 if (TYPE_READONLY (v) != constp
1527 || TYPE_VOLATILE (v) != volatilep)
1528 continue;
1529
1530 /* @@ This should do set equality, not exact match. */
1531 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v), raises))
1532 /* List of exceptions raised matches previously found list.
1533
1534 @@ Nice to free up storage used in consing up the
1535 @@ list of exceptions raised. */
1536 return v;
1537 }
1538
1539 /* Need to build a new variant. */
1540 v = build_type_copy (type);
1541
1542 if (raises && ! TREE_PERMANENT (raises))
1543 {
1544 push_obstacks_nochange ();
1545 end_temporary_allocation ();
1546 raises = copy_list (raises);
1547 pop_obstacks ();
1548 }
1549
1550 TYPE_RAISES_EXCEPTIONS (v) = raises;
1551 return v;
1552}
1553
1554/* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1555 lang_specific field and its corresponding TEMPLATE_DECL node */
1556
1557tree
1558copy_template_template_parm (t)
1559 tree t;
1560{
1561 tree template = TYPE_NAME (t);
1562 tree t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1563 template = copy_node (template);
1564 copy_lang_decl (template);
1565 TREE_TYPE (template) = t2;
1566 TYPE_NAME (t2) = template;
1567 TYPE_STUB_DECL (t2) = template;
1568
1569 /* No need to copy these */
1570 TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1571 CLASSTYPE_TEMPLATE_INFO (t2) = CLASSTYPE_TEMPLATE_INFO (t);
1572 return t2;
1573}
1574
1575/* Subroutine of copy_to_permanent
1576
1577 Assuming T is a node build bottom-up, make it all exist on
1578 permanent obstack, if it is not permanent already. */
1579
1580tree
1581mapcar (t, func)
1582 tree t;
1583 tree (*func) PROTO((tree));
1584{
1585 tree tmp;
1586
1587 if (t == NULL_TREE)
1588 return t;
1589
1590 if (tmp = func (t), tmp != NULL_TREE)
1591 return tmp;
1592
1593 switch (TREE_CODE (t))
1594 {
1595 case ERROR_MARK:
1596 return error_mark_node;
1597
1598 case VAR_DECL:
1599 case FUNCTION_DECL:
1600 case CONST_DECL:
1601 /* Rather than aborting, return error_mark_node. This allows us
1602 to report a sensible error message on code like this:
1603
1604 void g() { int i; f<i>(7); }
1605
1606 In a case like:
1607
1608 void g() { const int i = 7; f<i>(7); }
1609
1610 however, we must actually return the constant initializer. */
1611 tmp = decl_constant_value (t);
1612 if (tmp != t)
1613 return mapcar (tmp, func);
1614 else
1615 return error_mark_node;
1616
1617 case PARM_DECL:
1618 {
1619 tree chain = TREE_CHAIN (t);
1620 t = copy_node (t);
1621 TREE_CHAIN (t) = mapcar (chain, func);
1622 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1623 DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
--- 30 unchanged lines hidden (view full) ---
1654 return t;
1655 }
1656
1657 case INTEGER_CST:
1658 case REAL_CST:
1659 case STRING_CST:
1660 return copy_node (t);
1661
1662 case COND_EXPR:
1663 case TARGET_EXPR:
1664 case AGGR_INIT_EXPR:
1665 t = copy_node (t);
1666 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1667 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1668 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1669 return t;
--- 47 unchanged lines hidden (view full) ---
1717
1718 case CALL_EXPR:
1719 t = copy_node (t);
1720 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1721 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1722 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1723
1724 /* tree.def says that operand two is RTL, but
1725 build_call_declarator puts trees in there. */
1726 if (TREE_OPERAND (t, 2)
1727 && TREE_CODE (TREE_OPERAND (t, 2)) == TREE_LIST)
1728 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1729 else
1730 TREE_OPERAND (t, 2) = NULL_TREE;
1731 return t;
1732
1733 case CONVERT_EXPR:
1734 case ADDR_EXPR:
1735 case INDIRECT_REF:
1736 case NEGATE_EXPR:
1737 case BIT_NOT_EXPR:
1738 case TRUTH_NOT_EXPR:
1739 case NOP_EXPR:
1740 case COMPONENT_REF:
1741 case CLEANUP_POINT_EXPR:
1742 t = copy_node (t);
1743 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1744 return t;
1745
1746 case POINTER_TYPE:
1747 tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1748 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1749 case REFERENCE_TYPE:
1750 tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1751 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1752 case FUNCTION_TYPE:
1753 tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1754 mapcar (TYPE_ARG_TYPES (t), func));
1755 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1756 case ARRAY_TYPE:
1757 tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1758 mapcar (TYPE_DOMAIN (t), func));
1759 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1760 case INTEGER_TYPE:
1761 tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1762 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1763 case OFFSET_TYPE:
1764 tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1765 mapcar (TREE_TYPE (t), func));
1766 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1767 case METHOD_TYPE:
1768 tmp = build_cplus_method_type
1769 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1770 mapcar (TREE_TYPE (t), func),
1771 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1772 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1773
1774 case COMPLEX_CST:
1775 t = copy_node (t);
1776 TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
1777 TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
1778 return t;
1779
1780 case CONSTRUCTOR:
--- 13 unchanged lines hidden (view full) ---
1794
1795 case NEW_EXPR:
1796 t = copy_node (t);
1797 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1798 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1799 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1800 return t;
1801
1802 case RECORD_TYPE:
1803 if (TYPE_PTRMEMFUNC_P (t))
1804 return build_ptrmemfunc_type
1805 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
1806 /* else fall through */
1807
1808 /* This list is incomplete, but should suffice for now.
1809 It is very important that `sorry' not call
1810 `report_error_function'. That could cause an infinite loop. */
1811 default:
1812 sorry ("initializer contains unrecognized tree code");
1813 return error_mark_node;
1814
1815 }
1816 my_friendly_abort (107);
1817 /* NOTREACHED */
1818 return NULL_TREE;
1819}
1820
1821static tree
1822perm_manip (t)
1823 tree t;
1824{
1825 if (TREE_PERMANENT (t))
1826 return t;
1827
1828 /* Support `void f () { extern int i; A<&i> a; }' */
--- 51 unchanged lines hidden (view full) ---
1880
1881/* This is used by the `assert' macro. It is provided in libgcc.a,
1882 which `cc' doesn't know how to link. Note that the C++ front-end
1883 no longer actually uses the `assert' macro (instead, it calls
1884 my_friendly_assert). But all of the back-end files still need this. */
1885
1886void
1887__eprintf (string, expression, line, filename)
1888#ifdef __STDC__
1889 const char *string;
1890 const char *expression;
1891 unsigned line;
1892 const char *filename;
1893#else
1894 char *string;
1895 char *expression;
1896 unsigned line;
1897 char *filename;
1898#endif
1899{
1900 fprintf (stderr, string, expression, line, filename);
1901 fflush (stderr);
1902 abort ();
1903}
1904
1905/* Return, as an INTEGER_CST node, the number of elements for TYPE
1906 (which is an ARRAY_TYPE). This counts only elements of the top
--- 125 unchanged lines hidden (view full) ---
2032 code = va_arg (p, enum tree_code);
2033 tt = va_arg (p, tree);
2034#endif
2035
2036 expression_obstack = &permanent_obstack;
2037
2038 t = make_node (code);
2039 length = tree_code_length[(int) code];
2040 TREE_TYPE (t) = tt;
2041 TREE_COMPLEXITY (t) = lineno;
2042
2043 for (i = 0; i < length; i++)
2044 {
2045 tree x = va_arg (p, tree);
2046 TREE_OPERAND (t, i) = copy_to_permanent (x);
2047 }
2048
--- 60 unchanged lines hidden (view full) ---
2109tree
2110vec_binfo_member (elem, vec)
2111 tree elem, vec;
2112{
2113 int i;
2114
2115 if (vec)
2116 for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2117 if (comptypes (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i)), 1))
2118 return TREE_VEC_ELT (vec, i);
2119
2120 return NULL_TREE;
2121}
2122
2123/* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2124 the wrong thing for decl_function_context. Hopefully the uses in the
2125 backend won't matter, since we don't need a static chain for local class
2126 methods. FIXME! */
2127
2128tree
2129hack_decl_function_context (decl)
2130 tree decl;
2131{
2132 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2133 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2134 return decl_function_context (decl);
2135}
2136
2137/* Return truthvalue of whether T1 is the same tree structure as T2.
2138 Return 1 if they are the same.
2139 Return 0 if they are understandably different.
2140 Return -1 if either contains tree structure not understood by
2141 this function. */
2142
2143int
2144cp_tree_equal (t1, t2)
--- 37 unchanged lines hidden (view full) ---
2182 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2183 && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2184 TREE_STRING_LENGTH (t1));
2185
2186 case CONSTRUCTOR:
2187 /* We need to do this when determining whether or not two
2188 non-type pointer to member function template arguments
2189 are the same. */
2190 if (!(comptypes (TREE_TYPE (t1), TREE_TYPE (t2), 1)
2191 /* The first operand is RTL. */
2192 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2193 return 0;
2194 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2195
2196 case TREE_LIST:
2197 cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2198 if (cmp <= 0)
--- 51 unchanged lines hidden (view full) ---
2250 return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2251 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2252
2253 case SIZEOF_EXPR:
2254 case ALIGNOF_EXPR:
2255 if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2256 return 0;
2257 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2258 return comptypes (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0), 1);
2259 break;
2260
2261 default:
2262 break;
2263 }
2264
2265 switch (TREE_CODE_CLASS (code1))
2266 {
2267 int i;
2268 case '1':
--- 10 unchanged lines hidden (view full) ---
2279 return cmp;
2280 }
2281 return cmp;
2282 }
2283
2284 return -1;
2285}
2286
2287/* Similar to make_tree_vec, but build on a temporary obstack. */
2288
2289tree
2290make_temp_vec (len)
2291 int len;
2292{
2293 register tree node;
2294 register struct obstack *ambient_obstack = current_obstack;
2295 current_obstack = expression_obstack;
2296 node = make_tree_vec (len);
2297 current_obstack = ambient_obstack;
2298 return node;
2299}
2300
2301/* Build a wrapper around some pointer PTR so we can use it as a tree. */
2302
2303tree
2304build_ptr_wrapper (ptr)
2305 void *ptr;
--- 22 unchanged lines hidden (view full) ---
2328build_int_wrapper (i)
2329 int i;
2330{
2331 tree t = make_node (WRAPPER);
2332 WRAPPER_INT (t) = i;
2333 return t;
2334}
2335
2336tree
2337build_srcloc (file, line)
2338 char *file;
2339 int line;
2340{
2341 tree t;
2342
2343 /* Make sure that we put these on the permanent obstack; up in
2344 add_pending_template, we pass this return value into perm_tree_cons,
--- 28 unchanged lines hidden (view full) ---
2373
2374tree
2375lvalue_type (arg)
2376 tree arg;
2377{
2378 tree type = TREE_TYPE (arg);
2379 if (TREE_CODE (arg) == OVERLOAD)
2380 type = unknown_type_node;
2381 return cp_build_type_variant
2382 (type, TREE_READONLY (arg), TREE_THIS_VOLATILE (arg));
2383}
2384
2385/* The type of ARG for printing error messages; denote lvalues with
2386 reference types. */
2387
2388tree
2389error_type (arg)
2390 tree arg;
--- 26 unchanged lines hidden (view full) ---
2417
2418int
2419member_p (decl)
2420 tree decl;
2421{
2422 tree ctx = DECL_CONTEXT (decl);
2423 return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');
2424}
2 Copyright (C) 1987, 88, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
4
5This file is part of GNU CC.
6
7GNU CC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
--- 12 unchanged lines hidden (view full) ---
23#include "system.h"
24#include "obstack.h"
25#include "tree.h"
26#include "cp-tree.h"
27#include "flags.h"
28#include "rtl.h"
29#include "toplev.h"
30
31#ifdef __STDC__
32#include <stdarg.h>
33#else
34#include <varargs.h>
35#endif
36
37extern void compiler_error ();
38
39static tree get_identifier_list PROTO((tree));
40static tree bot_manip PROTO((tree));
41static tree perm_manip PROTO((tree));
42static tree build_cplus_array_type_1 PROTO((tree, tree));
43static void list_hash_add PROTO((int, tree));
44static int list_hash PROTO((tree, tree, tree));
45static tree list_hash_lookup PROTO((int, int, int, int, tree, tree,
46 tree));
47static void propagate_binfo_offsets PROTO((tree, tree));
48static void unshare_base_binfos PROTO((tree));
49static int avoid_overlap PROTO((tree, tree));
50static int equal_functions PROTO((tree, tree));
51
52#define CEIL(x,y) (((x) + (y) - 1) / (y))
53
54/* Return nonzero if REF is an lvalue valid for this language.
55 Lvalues can be assigned, unless they have TREE_READONLY.
56 Lvalues can have their address taken, unless they have DECL_REGISTER. */
57
58int
59real_lvalue_p (ref)
60 tree ref;
61{
62 if (! language_lvalue_valid (ref))
63 return 0;
64
65 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
66 return 1;
67
68 if (ref == current_class_ptr && flag_this_is_variable <= 0)
69 return 0;
70
71 switch (TREE_CODE (ref))
72 {
73 /* preincrements and predecrements are valid lvals, provided
74 what they refer to are valid lvals. */
75 case PREINCREMENT_EXPR:
76 case PREDECREMENT_EXPR:
77 case COMPONENT_REF:
78 case SAVE_EXPR:
79 case UNSAVE_EXPR:
80 case TRY_CATCH_EXPR:
81 case WITH_CLEANUP_EXPR:
82 return real_lvalue_p (TREE_OPERAND (ref, 0));
83
84 case STRING_CST:
85 return 1;
86
87 case VAR_DECL:
88 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
89 && DECL_LANG_SPECIFIC (ref)
90 && DECL_IN_AGGR_P (ref))
91 return 0;
92 case INDIRECT_REF:
93 case ARRAY_REF:
94 case PARM_DECL:
95 case RESULT_DECL:
96 case ERROR_MARK:
97 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
98 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
99 return 1;
100 break;
101
102 /* A currently unresolved scope ref. */
103 case SCOPE_REF:
104 my_friendly_abort (103);
105 case OFFSET_REF:
106 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
107 return 1;
108 return real_lvalue_p (TREE_OPERAND (ref, 0))
109 && real_lvalue_p (TREE_OPERAND (ref, 1));
110 break;
111
112 case COND_EXPR:
113 return (real_lvalue_p (TREE_OPERAND (ref, 1))
114 && real_lvalue_p (TREE_OPERAND (ref, 2)));
115
116 case MODIFY_EXPR:
117 return 1;
118
119 case COMPOUND_EXPR:
120 return real_lvalue_p (TREE_OPERAND (ref, 1));
121
122 case MAX_EXPR:
123 case MIN_EXPR:
124 return (real_lvalue_p (TREE_OPERAND (ref, 0))
125 && real_lvalue_p (TREE_OPERAND (ref, 1)));
126
127 default:
128 break;
129 }
130
131 return 0;
132}
133
134/* This differs from real_lvalue_p in that class rvalues are considered
135 lvalues. */
136int
137lvalue_p (ref)
138 tree ref;
139{
140 if (! language_lvalue_valid (ref))
141 return 0;
142
143 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
144 return 1;
145
146 if (ref == current_class_ptr && flag_this_is_variable <= 0)
147 return 0;
148
149 switch (TREE_CODE (ref))
150 {
151 /* preincrements and predecrements are valid lvals, provided
152 what they refer to are valid lvals. */
153 case PREINCREMENT_EXPR:
154 case PREDECREMENT_EXPR:
155 case REALPART_EXPR:
156 case IMAGPART_EXPR:
157 case COMPONENT_REF:
158 case SAVE_EXPR:
159 case UNSAVE_EXPR:
160 case TRY_CATCH_EXPR:
161 case WITH_CLEANUP_EXPR:
162 return lvalue_p (TREE_OPERAND (ref, 0));
163
164 case STRING_CST:
165 return 1;
166
167 case VAR_DECL:
168 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
169 && DECL_LANG_SPECIFIC (ref)
170 && DECL_IN_AGGR_P (ref))
171 return 0;
172 case INDIRECT_REF:
173 case ARRAY_REF:
174 case PARM_DECL:
175 case RESULT_DECL:
176 case ERROR_MARK:
177 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
178 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
179 return 1;
180 break;
181
182 case TARGET_EXPR:
183 return 1;
184
185 case CALL_EXPR:
186 if (IS_AGGR_TYPE (TREE_TYPE (ref)))
187 return 1;
188 break;
189
190 /* A currently unresolved scope ref. */
191 case SCOPE_REF:
192 my_friendly_abort (103);
193 case OFFSET_REF:
194 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
195 return 1;
196 return lvalue_p (TREE_OPERAND (ref, 0))
197 && lvalue_p (TREE_OPERAND (ref, 1));
198 break;
199
200 case COND_EXPR:
201 return (lvalue_p (TREE_OPERAND (ref, 1))
202 && lvalue_p (TREE_OPERAND (ref, 2)));
203
204 case MODIFY_EXPR:
205 return 1;
206
207 case COMPOUND_EXPR:
208 return lvalue_p (TREE_OPERAND (ref, 1));
209
210 case MAX_EXPR:
211 case MIN_EXPR:
212 return (lvalue_p (TREE_OPERAND (ref, 0))
213 && lvalue_p (TREE_OPERAND (ref, 1)));
214
215 default:
216 break;
217 }
218
219 return 0;
220}
221
222/* Return nonzero if REF is an lvalue valid for this language;
223 otherwise, print an error message and return zero. */
224
225int
226lvalue_or_else (ref, string)
227 tree ref;
228 char *string;
229{
230 int win = lvalue_p (ref);
231 if (! win)
232 error ("non-lvalue in %s", string);
233 return win;
234}
235
236/* INIT is a CALL_EXPR which needs info about its target.
--- 7 unchanged lines hidden (view full) ---
244build_cplus_new (type, init)
245 tree type;
246 tree init;
247{
248 tree slot;
249 tree rval;
250
251 if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
252 return init;
253
254 slot = build (VAR_DECL, type);
255 DECL_ARTIFICIAL (slot) = 1;
256 layout_decl (slot, 0);
257 rval = build (AGGR_INIT_EXPR, type,
258 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
259 TREE_SIDE_EFFECTS (rval) = 1;
260 rval = build (TARGET_EXPR, type, slot, rval, NULL_TREE, NULL_TREE);
--- 165 unchanged lines hidden (view full) ---
426 int hashcode;
427
428 /* Make a node of the sort we want. */
429 t = make_node (METHOD_TYPE);
430
431 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
432 TREE_TYPE (t) = rettype;
433 if (IS_SIGNATURE (basetype))
434 ptype = build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype),
435 TYPE_READONLY (basetype),
436 TYPE_VOLATILE (basetype));
437 else
438 ptype = build_pointer_type (basetype);
439
440 /* The actual arglist for this function includes a "hidden" argument
441 which is "this". Put it into the list of argument types. */
442
443 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
444 TYPE_ARG_TYPES (t) = argtypes;
--- 23 unchanged lines hidden (view full) ---
468 make this permanent too. */
469 if (TREE_PERMANENT (elt_type)
470 && (index_type == 0 || TREE_PERMANENT (index_type)))
471 {
472 current_obstack = &permanent_obstack;
473 saveable_obstack = &permanent_obstack;
474 }
475
476 if (processing_template_decl
477 || uses_template_parms (index_type))
478 {
479 t = make_node (ARRAY_TYPE);
480 TREE_TYPE (t) = elt_type;
481 TYPE_DOMAIN (t) = index_type;
482 }
483 else
484 t = build_array_type (elt_type, index_type);
--- 8 unchanged lines hidden (view full) ---
493}
494
495tree
496build_cplus_array_type (elt_type, index_type)
497 tree elt_type;
498 tree index_type;
499{
500 tree t;
501 int constp = TYPE_READONLY (elt_type);
502 int volatilep = TYPE_VOLATILE (elt_type);
503 elt_type = TYPE_MAIN_VARIANT (elt_type);
504
505 t = build_cplus_array_type_1 (elt_type, index_type);
506
507 if (constp || volatilep)
508 t = cp_build_type_variant (t, constp, volatilep);
509
510 return t;
511}
512
513/* Make a variant type in the proper way for C/C++, propagating qualifiers
514 down to the element type of an array. */
515
516tree
517cp_build_type_variant (type, constp, volatilep)
518 tree type;
519 int constp, volatilep;
520{
521 if (type == error_mark_node)
522 return type;
523
524 if (TREE_CODE (type) == ARRAY_TYPE)
525 {
526 tree real_main_variant = TYPE_MAIN_VARIANT (type);
527
528 push_obstacks (TYPE_OBSTACK (real_main_variant),
529 TYPE_OBSTACK (real_main_variant));
530 type = build_cplus_array_type_1 (cp_build_type_variant
531 (TREE_TYPE (type), constp, volatilep),
532 TYPE_DOMAIN (type));
533
534 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
535 make a copy. (TYPE might have come from the hash table and
536 REAL_MAIN_VARIANT might be in some function's obstack.) */
537
538 if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant))
539 {
540 type = copy_node (type);
541 TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0;
542 }
543
544 TYPE_MAIN_VARIANT (type) = real_main_variant;
545 pop_obstacks ();
546 return type;
547 }
548 return build_type_variant (type, constp, volatilep);
549}
550
551/* Returns the canonical version of TYPE. In other words, if TYPE is
552 a typedef, returns the underlying type. The cv-qualification of
553 the type returned matches the type input; they will always be
554 compatible types. */
555
556tree
557canonical_type_variant (t)
558 tree t;
559{
560 int constp, volatilep;
561 if (TREE_CODE (t) == ARRAY_TYPE)
562 {
563 constp = TYPE_READONLY (TREE_TYPE (t));
564 volatilep = TYPE_VOLATILE (TREE_TYPE (t));
565 }
566 else
567 {
568 constp = TYPE_READONLY (t);
569 volatilep = TYPE_VOLATILE (t);
570 }
571 return cp_build_type_variant (TYPE_MAIN_VARIANT (t), constp, volatilep);
572}
573
574/* Add OFFSET to all base types of T.
575
576 OFFSET, which is a type offset, is number of bytes.
577
578 Note that we don't have to worry about having two paths to the
579 same base type, since this type owns its association list. */
--- 33 unchanged lines hidden (view full) ---
613 BINFO_OFFSET (base_binfo) = offset;
614 else
615 BINFO_OFFSET (base_binfo)
616 = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
617#else
618 BINFO_OFFSET (base_binfo) = offset;
619#endif
620
621 unshare_base_binfos (base_binfo);
622
623 /* Go to our next class that counts for offset propagation. */
624 i = j;
625 if (i < n_baselinks)
626 offset = size_binop (PLUS_EXPR, offset, delta);
627 }
628 }
629}
630
631/* Makes new binfos for the indirect bases under BASE_BINFO, and updates
632 BINFO_OFFSET for them and their bases. */
633
634static void
635unshare_base_binfos (base_binfo)
636 tree base_binfo;
637{
638 if (BINFO_BASETYPES (base_binfo))
639 {
640 tree base_binfos = BINFO_BASETYPES (base_binfo);
641 tree chain = NULL_TREE;
642 int j;
643
644 /* Now unshare the structure beneath BASE_BINFO. */
645 for (j = TREE_VEC_LENGTH (base_binfos)-1;
646 j >= 0; j--)
647 {
648 tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
649 if (! TREE_VIA_VIRTUAL (base_base_binfo))
650 TREE_VEC_ELT (base_binfos, j)
651 = make_binfo (BINFO_OFFSET (base_base_binfo),
652 base_base_binfo,
653 BINFO_VTABLE (base_base_binfo),
654 BINFO_VIRTUALS (base_base_binfo),
655 chain);
656 chain = TREE_VEC_ELT (base_binfos, j);
657 TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
658 TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
659 BINFO_INHERITANCE_CHAIN (chain) = base_binfo;
660 }
661
662 /* Completely unshare potentially shared data, and
663 update what is ours. */
664 propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
665 }
666}
667
668/* Finish the work of layout_record, now taking virtual bases into account.
669 Also compute the actual offsets that our base classes will have.
670 This must be performed after the fields are laid out, since virtual
671 baseclasses must lay down at the end of the record.
672
673 Returns the maximum number of virtual functions any of the
674 baseclasses provide. */
675
676int
677layout_basetypes (rec, max)
678 tree rec;
679 int max;
680{
681 tree binfos = TYPE_BINFO_BASETYPES (rec);
682 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
683
684 /* Get all the virtual base types that this type uses.
685 The TREE_VALUE slot holds the virtual baseclass type. */
686 tree vbase_types = get_vbase_types (rec);
687
688 unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
689 unsigned int desired_align;
690
691 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
692 register unsigned int const_size = 0;
693 unsigned int nonvirtual_const_size;
694
695#ifdef STRUCTURE_SIZE_BOUNDARY
696 /* Packed structures don't need to have minimum size. */
697 if (! TYPE_PACKED (rec))
698 record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY);
699#endif
700
701 CLASSTYPE_VBASECLASSES (rec) = vbase_types;
702
703 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST, 19970302);
704 const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
705
706 nonvirtual_const_size = const_size;
707
708 while (vbase_types)
709 {
--- 49 unchanged lines hidden (view full) ---
759 register tree base_binfo = TREE_VEC_ELT (binfos, i);
760 register tree basetype = BINFO_TYPE (base_binfo);
761 tree field = TYPE_FIELDS (rec);
762
763 if (TREE_VIA_VIRTUAL (base_binfo))
764 continue;
765
766 my_friendly_assert (TREE_TYPE (field) == basetype, 23897);
767 BINFO_OFFSET (base_binfo)
768 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)),
769 BITS_PER_UNIT));
770 unshare_base_binfos (base_binfo);
771 TYPE_FIELDS (rec) = TREE_CHAIN (field);
772 }
773
774 for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
775 vbase_types = TREE_CHAIN (vbase_types))
776 {
777 BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec);
778 unshare_base_binfos (vbase_types);
779 }
780
781 return max;
782}
783
784/* If the empty base field in DECL overlaps with a base of the same type in
785 NEWDECL, which is either another base field or the first data field of
786 the class, pad the base just before NEWDECL and return 1. Otherwise,
--- 59 unchanged lines hidden (view full) ---
846 {
847 /* Brain damage for backwards compatibility. For no good reason,
848 the old layout_basetypes made every base at least as large as
849 the alignment for the bases up to that point, gratuitously
850 wasting space. So we do the same thing here. */
851 base_align = MAX (base_align, DECL_ALIGN (decl));
852 DECL_SIZE (decl)
853 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
854 base_align));
855 }
856 else if (DECL_SIZE (decl) == integer_zero_node)
857 saw_empty = 1;
858 }
859
860 /* Reverse the list of fields so we allocate the bases in the proper
861 order. */
862 base_decls = nreverse (base_decls);
--- 57 unchanged lines hidden (view full) ---
920 continue;
921
922 /* All basetypes are recorded in the association list of the
923 derived type. */
924
925 if (TREE_VIA_VIRTUAL (base_binfo))
926 {
927 int j;
928 char *name = (char *)alloca (TYPE_NAME_LENGTH (basetype)
929 + sizeof (VBASE_NAME) + 1);
930
931 /* The offset for a virtual base class is only used in computing
932 virtual function tables and for initializing virtual base
933 pointers. It is built once `get_vbase_types' is called. */
934
935 /* If this basetype can come from another vbase pointer
936 without an additional indirection, we will share
937 that pointer. If an indirection is involved, we
938 make our own pointer. */
939 for (j = 0; j < n_baseclasses; j++)
940 {
941 tree other_base_binfo = TREE_VEC_ELT (binfos, j);
942 if (! TREE_VIA_VIRTUAL (other_base_binfo)
943 && binfo_member (basetype,
944 CLASSTYPE_VBASECLASSES (BINFO_TYPE
945 (other_base_binfo))
946 ))
947 goto got_it;
948 }
949 sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (basetype));
950 decl = build_lang_field_decl (FIELD_DECL, get_identifier (name),
951 build_pointer_type (basetype));
952 /* If you change any of the below, take a look at all the
953 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
954 them too. */
955 DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
956 DECL_VIRTUAL_P (decl) = 1;
957 DECL_ARTIFICIAL (decl) = 1;
--- 61 unchanged lines hidden (view full) ---
1019 hashcode += 1009;
1020 return hashcode;
1021}
1022
1023/* Look in the type hash table for a type isomorphic to TYPE.
1024 If one is found, return it. Otherwise return 0. */
1025
1026static tree
1027list_hash_lookup (hashcode, via_public, via_protected, via_virtual,
1028 purpose, value, chain)
1029 int hashcode, via_public, via_virtual, via_protected;
1030 tree purpose, value, chain;
1031{
1032 register struct list_hash *h;
1033
1034 for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
1035 if (h->hashcode == hashcode
1036 && TREE_VIA_VIRTUAL (h->list) == via_virtual
1037 && TREE_VIA_PUBLIC (h->list) == via_public
1038 && TREE_VIA_PROTECTED (h->list) == via_protected
1039 && TREE_PURPOSE (h->list) == purpose
1040 && TREE_VALUE (h->list) == value
1041 && TREE_CHAIN (h->list) == chain)
1042 return h->list;
1043 return 0;
1044}
1045
1046/* Add an entry to the list-hash-table
--- 8 unchanged lines hidden (view full) ---
1055
1056 h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
1057 h->hashcode = hashcode;
1058 h->list = list;
1059 h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
1060 list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
1061}
1062
1063/* Given TYPE, and HASHCODE its hash code, return the canonical
1064 object for an identical list if one already exists.
1065 Otherwise, return TYPE, and record it as the canonical object
1066 if it is a permanent object.
1067
1068 To use this function, first create a list of the sort you want.
1069 Then compute its hash code from the fields of the list that
1070 make it different from other similar lists.
1071 Then call this function and use the value.
1072 This function frees the list you pass in if it is a duplicate. */
1073
1074/* Set to 1 to debug without canonicalization. Never set by program. */
1075
1076static int debug_no_list_hash = 0;
1077
1078tree
1079hash_tree_cons (via_public, via_virtual, via_protected, purpose, value, chain)
1080 int via_public, via_virtual, via_protected;
1081 tree purpose, value, chain;
1082{
1083 struct obstack *ambient_obstack = current_obstack;
1084 tree t;
1085 int hashcode = 0;
1086
1087 if (! debug_no_list_hash)
1088 {
1089 hashcode = list_hash (purpose, value, chain);
1090 t = list_hash_lookup (hashcode, via_public, via_protected, via_virtual,
1091 purpose, value, chain);
1092 if (t)
1093 return t;
1094 }
1095
1096 current_obstack = &class_obstack;
1097
1098 t = tree_cons (purpose, value, chain);
1099 TREE_VIA_PUBLIC (t) = via_public;
1100 TREE_VIA_PROTECTED (t) = via_protected;
1101 TREE_VIA_VIRTUAL (t) = via_virtual;
1102
1103 /* If this is a new list, record it for later reuse. */
1104 if (! debug_no_list_hash)
1105 list_hash_add (hashcode, t);
1106
1107 current_obstack = ambient_obstack;
1108 return t;
1109}
1110
1111/* Constructor for hashed lists. */
1112
1113tree
1114hash_tree_chain (value, chain)
1115 tree value, chain;
1116{
1117 return hash_tree_cons (0, 0, 0, NULL_TREE, value, chain);
1118}
1119
1120/* Similar, but used for concatenating two lists. */
1121
1122tree
1123hash_chainon (list1, list2)
1124 tree list1, list2;
1125{
1126 if (list2 == 0)
1127 return list1;
1128 if (list1 == 0)
1129 return list2;
1130 if (TREE_CHAIN (list1) == NULL_TREE)
1131 return hash_tree_chain (TREE_VALUE (list1), list2);
1132 return hash_tree_chain (TREE_VALUE (list1),
1133 hash_chainon (TREE_CHAIN (list1), list2));
1134}
1135
1136static tree
1137get_identifier_list (value)
1138 tree value;
1139{
1140 tree list = IDENTIFIER_AS_LIST (value);
1141 if (list != NULL_TREE
1142 && (TREE_CODE (list) != TREE_LIST
1143 || TREE_VALUE (list) != value))
1144 list = NULL_TREE;
1145 else if (IDENTIFIER_HAS_TYPE_VALUE (value)
1146 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE
1147 && IDENTIFIER_TYPE_VALUE (value)
1148 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value)))
1149 {
1150 tree type = IDENTIFIER_TYPE_VALUE (value);
1151
1152 if (TYPE_PTRMEMFUNC_P (type))
1153 list = NULL_TREE;
1154 else if (type == current_class_type)
1155 /* Don't mess up the constructor name. */
1156 list = tree_cons (NULL_TREE, value, NULL_TREE);
1157 else
1158 {
1159 if (! CLASSTYPE_ID_AS_LIST (type))
1160 CLASSTYPE_ID_AS_LIST (type)
1161 = perm_tree_cons (NULL_TREE, TYPE_IDENTIFIER (type), NULL_TREE);
1162 list = CLASSTYPE_ID_AS_LIST (type);
1163 }
1164 }
1165 return list;
1166}
1167
1168tree
1169get_decl_list (value)
1170 tree value;
1171{
1172 tree list = NULL_TREE;
1173
1174 if (TREE_CODE (value) == IDENTIFIER_NODE)
1175 list = get_identifier_list (value);
1176 else if (TREE_CODE (value) == RECORD_TYPE
1177 && TYPE_LANG_SPECIFIC (value)
1178 && value == TYPE_MAIN_VARIANT (value))
1179 list = CLASSTYPE_AS_LIST (value);
1180
1181 if (list != NULL_TREE)
1182 {
1183 my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 301);
1184 return list;
1185 }
1186
1187 return build_decl_list (NULL_TREE, value);
1188}
1189
1190/* Build an association between TYPE and some parameters:
1191
1192 OFFSET is the offset added to `this' to convert it to a pointer
1193 of type `TYPE *'
1194
1195 BINFO is the base binfo to use, if we are deriving from one. This
1196 is necessary, as we want specialized parent binfos from base
1197 classes, so that the VTABLE_NAMEs of bases are for the most derived
1198 type, instead of the simple type.
1199
1200 VTABLE is the virtual function table with which to initialize
1201 sub-objects of type TYPE.
1202
1203 VIRTUALS are the virtual functions sitting in VTABLE.
1204
1205 CHAIN are more associations we must retain. */
1206
1207tree
1208make_binfo (offset, binfo, vtable, virtuals, chain)
1209 tree offset, binfo;
1210 tree vtable, virtuals;
1211 tree chain;
1212{
1213 tree new_binfo = make_tree_vec (7);
1214 tree type;
1215
1216 if (TREE_CODE (binfo) == TREE_VEC)
1217 type = BINFO_TYPE (binfo);
1218 else
1219 {
1220 type = binfo;
1221 binfo = TYPE_BINFO (binfo);
1222 }
1223
1224 TREE_CHAIN (new_binfo) = chain;
1225 if (chain)
1226 TREE_USED (new_binfo) = TREE_USED (chain);
1227
1228 TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
1229 BINFO_OFFSET (new_binfo) = offset;
1230 BINFO_VTABLE (new_binfo) = vtable;
1231 BINFO_VIRTUALS (new_binfo) = virtuals;
1232 BINFO_VPTR_FIELD (new_binfo) = NULL_TREE;
1233
1234 if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE)
1235 BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
--- 12 unchanged lines hidden (view full) ---
1248 TYPE_NAME_STRING (elem));
1249 if (elem == type)
1250 return TYPE_BINFO (type);
1251 if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1252 return type;
1253 return get_binfo (elem, type, 0);
1254}
1255
1256tree
1257reverse_path (path)
1258 tree path;
1259{
1260 register tree prev = 0, tmp, next;
1261 for (tmp = path; tmp; tmp = next)
1262 {
1263 next = BINFO_INHERITANCE_CHAIN (tmp);
1264 BINFO_INHERITANCE_CHAIN (tmp) = prev;
1265 prev = tmp;
1266 }
1267 return prev;
1268}
1269
1270void
1271debug_binfo (elem)
1272 tree elem;
1273{
1274 unsigned HOST_WIDE_INT n;
--- 6 unchanged lines hidden (view full) ---
1281 debug_tree (BINFO_TYPE (elem));
1282 if (BINFO_VTABLE (elem))
1283 fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1284 else
1285 fprintf (stderr, "no vtable decl yet\n");
1286 fprintf (stderr, "virtuals:\n");
1287 virtuals = BINFO_VIRTUALS (elem);
1288
1289 n = skip_rtti_stuff (&virtuals);
1290
1291 while (virtuals)
1292 {
1293 tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
1294 fprintf (stderr, "%s [%ld =? %ld]\n",
1295 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1296 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1297 ++n;
--- 37 unchanged lines hidden (view full) ---
1335 my_friendly_abort (359);
1336 return 0;
1337}
1338
1339int
1340is_overloaded_fn (x)
1341 tree x;
1342{
1343 /* XXX A baselink is also considered an overloaded function.
1344 As is a placeholder from push_class_decls. */
1345 if (TREE_CODE (x) == TREE_LIST)
1346 {
1347 my_friendly_assert (TREE_CODE (TREE_PURPOSE (x)) == TREE_VEC
1348 || TREE_CODE (TREE_PURPOSE (x)) == IDENTIFIER_NODE,
1349 388);
1350 x = TREE_VALUE (x);
1351 }
1352 return (TREE_CODE (x) == FUNCTION_DECL
1353 || TREE_CODE (x) == TEMPLATE_ID_EXPR
1354 || DECL_FUNCTION_TEMPLATE_P (x)
1355 || TREE_CODE (x) == OVERLOAD);
1356}
1357
1358int
1359really_overloaded_fn (x)
1360 tree x;
1361{
1362 /* A baselink is also considered an overloaded function.
1363 This might also be an ambiguous class member. */
1364 if (TREE_CODE (x) == TREE_LIST)
1365 x = TREE_VALUE (x);
1366 return (TREE_CODE (x) == OVERLOAD
1367 && (TREE_CHAIN (x) != NULL_TREE
1368 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1369}
1370
1371tree
1372get_first_fn (from)
1373 tree from;
1374{
1375 my_friendly_assert (is_overloaded_fn (from), 9);
1376 /* A baselink is also considered an overloaded function. */
1377 if (TREE_CODE (from) == TREE_LIST)
1378 from = TREE_VALUE (from);
1379 return OVL_CURRENT (from);
1380}
1381
1382/* Return a new OVL node, concatenating it with the old one. */
1383
1384tree
1385ovl_cons (decl, chain)
1386 tree decl;
1387 tree chain;
1388{
1389 tree result = make_node (OVERLOAD);
--- 22 unchanged lines hidden (view full) ---
1412/* Build a new overloaded function. If this is the first one,
1413 just return it; otherwise, ovl_cons the _DECLs */
1414
1415tree
1416build_overload (decl, chain)
1417 tree decl;
1418 tree chain;
1419{
1420 if (!chain)
1421 return decl;
1422 if (TREE_CODE (chain) != OVERLOAD)
1423 chain = ovl_cons (chain, NULL_TREE);
1424 return ovl_cons (decl, chain);
1425}
1426
1427/* Returns true iff functions are equivalent. Equivalent functions are
1428 not identical only if one is a function-local extern function.
1429 This assumes that function-locals don't have TREE_PERMANENT. */
1430
--- 82 unchanged lines hidden (view full) ---
1513 listed in RAISES. */
1514
1515tree
1516build_exception_variant (type, raises)
1517 tree type;
1518 tree raises;
1519{
1520 tree v = TYPE_MAIN_VARIANT (type);
1521 int constp = TYPE_READONLY (type);
1522 int volatilep = TYPE_VOLATILE (type);
1523
1524 for (; v; v = TYPE_NEXT_VARIANT (v))
1525 {
1526 if (TYPE_READONLY (v) != constp
1527 || TYPE_VOLATILE (v) != volatilep)
1528 continue;
1529
1530 /* @@ This should do set equality, not exact match. */
1531 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v), raises))
1532 /* List of exceptions raised matches previously found list.
1533
1534 @@ Nice to free up storage used in consing up the
1535 @@ list of exceptions raised. */
1536 return v;
1537 }
1538
1539 /* Need to build a new variant. */
1540 v = build_type_copy (type);
1541
1542 if (raises && ! TREE_PERMANENT (raises))
1543 {
1544 push_obstacks_nochange ();
1545 end_temporary_allocation ();
1546 raises = copy_list (raises);
1547 pop_obstacks ();
1548 }
1549
1550 TYPE_RAISES_EXCEPTIONS (v) = raises;
1551 return v;
1552}
1553
1554/* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1555 lang_specific field and its corresponding TEMPLATE_DECL node */
1556
1557tree
1558copy_template_template_parm (t)
1559 tree t;
1560{
1561 tree template = TYPE_NAME (t);
1562 tree t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1563 template = copy_node (template);
1564 copy_lang_decl (template);
1565 TREE_TYPE (template) = t2;
1566 TYPE_NAME (t2) = template;
1567 TYPE_STUB_DECL (t2) = template;
1568
1569 /* No need to copy these */
1570 TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1571 CLASSTYPE_TEMPLATE_INFO (t2) = CLASSTYPE_TEMPLATE_INFO (t);
1572 return t2;
1573}
1574
1575/* Subroutine of copy_to_permanent
1576
1577 Assuming T is a node build bottom-up, make it all exist on
1578 permanent obstack, if it is not permanent already. */
1579
1580tree
1581mapcar (t, func)
1582 tree t;
1583 tree (*func) PROTO((tree));
1584{
1585 tree tmp;
1586
1587 if (t == NULL_TREE)
1588 return t;
1589
1590 if (tmp = func (t), tmp != NULL_TREE)
1591 return tmp;
1592
1593 switch (TREE_CODE (t))
1594 {
1595 case ERROR_MARK:
1596 return error_mark_node;
1597
1598 case VAR_DECL:
1599 case FUNCTION_DECL:
1600 case CONST_DECL:
1601 /* Rather than aborting, return error_mark_node. This allows us
1602 to report a sensible error message on code like this:
1603
1604 void g() { int i; f<i>(7); }
1605
1606 In a case like:
1607
1608 void g() { const int i = 7; f<i>(7); }
1609
1610 however, we must actually return the constant initializer. */
1611 tmp = decl_constant_value (t);
1612 if (tmp != t)
1613 return mapcar (tmp, func);
1614 else
1615 return error_mark_node;
1616
1617 case PARM_DECL:
1618 {
1619 tree chain = TREE_CHAIN (t);
1620 t = copy_node (t);
1621 TREE_CHAIN (t) = mapcar (chain, func);
1622 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1623 DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
--- 30 unchanged lines hidden (view full) ---
1654 return t;
1655 }
1656
1657 case INTEGER_CST:
1658 case REAL_CST:
1659 case STRING_CST:
1660 return copy_node (t);
1661
1662 case COND_EXPR:
1663 case TARGET_EXPR:
1664 case AGGR_INIT_EXPR:
1665 t = copy_node (t);
1666 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1667 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1668 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1669 return t;
--- 47 unchanged lines hidden (view full) ---
1717
1718 case CALL_EXPR:
1719 t = copy_node (t);
1720 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1721 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1722 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1723
1724 /* tree.def says that operand two is RTL, but
1725 build_call_declarator puts trees in there. */
1726 if (TREE_OPERAND (t, 2)
1727 && TREE_CODE (TREE_OPERAND (t, 2)) == TREE_LIST)
1728 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1729 else
1730 TREE_OPERAND (t, 2) = NULL_TREE;
1731 return t;
1732
1733 case CONVERT_EXPR:
1734 case ADDR_EXPR:
1735 case INDIRECT_REF:
1736 case NEGATE_EXPR:
1737 case BIT_NOT_EXPR:
1738 case TRUTH_NOT_EXPR:
1739 case NOP_EXPR:
1740 case COMPONENT_REF:
1741 case CLEANUP_POINT_EXPR:
1742 t = copy_node (t);
1743 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1744 return t;
1745
1746 case POINTER_TYPE:
1747 tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1748 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1749 case REFERENCE_TYPE:
1750 tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1751 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1752 case FUNCTION_TYPE:
1753 tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1754 mapcar (TYPE_ARG_TYPES (t), func));
1755 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1756 case ARRAY_TYPE:
1757 tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1758 mapcar (TYPE_DOMAIN (t), func));
1759 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1760 case INTEGER_TYPE:
1761 tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1762 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1763 case OFFSET_TYPE:
1764 tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1765 mapcar (TREE_TYPE (t), func));
1766 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1767 case METHOD_TYPE:
1768 tmp = build_cplus_method_type
1769 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1770 mapcar (TREE_TYPE (t), func),
1771 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1772 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1773
1774 case COMPLEX_CST:
1775 t = copy_node (t);
1776 TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
1777 TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
1778 return t;
1779
1780 case CONSTRUCTOR:
--- 13 unchanged lines hidden (view full) ---
1794
1795 case NEW_EXPR:
1796 t = copy_node (t);
1797 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1798 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1799 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1800 return t;
1801
1802 case RECORD_TYPE:
1803 if (TYPE_PTRMEMFUNC_P (t))
1804 return build_ptrmemfunc_type
1805 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
1806 /* else fall through */
1807
1808 /* This list is incomplete, but should suffice for now.
1809 It is very important that `sorry' not call
1810 `report_error_function'. That could cause an infinite loop. */
1811 default:
1812 sorry ("initializer contains unrecognized tree code");
1813 return error_mark_node;
1814
1815 }
1816 my_friendly_abort (107);
1817 /* NOTREACHED */
1818 return NULL_TREE;
1819}
1820
1821static tree
1822perm_manip (t)
1823 tree t;
1824{
1825 if (TREE_PERMANENT (t))
1826 return t;
1827
1828 /* Support `void f () { extern int i; A<&i> a; }' */
--- 51 unchanged lines hidden (view full) ---
1880
1881/* This is used by the `assert' macro. It is provided in libgcc.a,
1882 which `cc' doesn't know how to link. Note that the C++ front-end
1883 no longer actually uses the `assert' macro (instead, it calls
1884 my_friendly_assert). But all of the back-end files still need this. */
1885
1886void
1887__eprintf (string, expression, line, filename)
1888#ifdef __STDC__
1889 const char *string;
1890 const char *expression;
1891 unsigned line;
1892 const char *filename;
1893#else
1894 char *string;
1895 char *expression;
1896 unsigned line;
1897 char *filename;
1898#endif
1899{
1900 fprintf (stderr, string, expression, line, filename);
1901 fflush (stderr);
1902 abort ();
1903}
1904
1905/* Return, as an INTEGER_CST node, the number of elements for TYPE
1906 (which is an ARRAY_TYPE). This counts only elements of the top
--- 125 unchanged lines hidden (view full) ---
2032 code = va_arg (p, enum tree_code);
2033 tt = va_arg (p, tree);
2034#endif
2035
2036 expression_obstack = &permanent_obstack;
2037
2038 t = make_node (code);
2039 length = tree_code_length[(int) code];
2040 TREE_TYPE (t) = tt;
2041 TREE_COMPLEXITY (t) = lineno;
2042
2043 for (i = 0; i < length; i++)
2044 {
2045 tree x = va_arg (p, tree);
2046 TREE_OPERAND (t, i) = copy_to_permanent (x);
2047 }
2048
--- 60 unchanged lines hidden (view full) ---
2109tree
2110vec_binfo_member (elem, vec)
2111 tree elem, vec;
2112{
2113 int i;
2114
2115 if (vec)
2116 for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2117 if (comptypes (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i)), 1))
2118 return TREE_VEC_ELT (vec, i);
2119
2120 return NULL_TREE;
2121}
2122
2123/* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2124 the wrong thing for decl_function_context. Hopefully the uses in the
2125 backend won't matter, since we don't need a static chain for local class
2126 methods. FIXME! */
2127
2128tree
2129hack_decl_function_context (decl)
2130 tree decl;
2131{
2132 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2133 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2134 return decl_function_context (decl);
2135}
2136
2137/* Return truthvalue of whether T1 is the same tree structure as T2.
2138 Return 1 if they are the same.
2139 Return 0 if they are understandably different.
2140 Return -1 if either contains tree structure not understood by
2141 this function. */
2142
2143int
2144cp_tree_equal (t1, t2)
--- 37 unchanged lines hidden (view full) ---
2182 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2183 && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2184 TREE_STRING_LENGTH (t1));
2185
2186 case CONSTRUCTOR:
2187 /* We need to do this when determining whether or not two
2188 non-type pointer to member function template arguments
2189 are the same. */
2190 if (!(comptypes (TREE_TYPE (t1), TREE_TYPE (t2), 1)
2191 /* The first operand is RTL. */
2192 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2193 return 0;
2194 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2195
2196 case TREE_LIST:
2197 cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2198 if (cmp <= 0)
--- 51 unchanged lines hidden (view full) ---
2250 return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2251 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2252
2253 case SIZEOF_EXPR:
2254 case ALIGNOF_EXPR:
2255 if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2256 return 0;
2257 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2258 return comptypes (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0), 1);
2259 break;
2260
2261 default:
2262 break;
2263 }
2264
2265 switch (TREE_CODE_CLASS (code1))
2266 {
2267 int i;
2268 case '1':
--- 10 unchanged lines hidden (view full) ---
2279 return cmp;
2280 }
2281 return cmp;
2282 }
2283
2284 return -1;
2285}
2286
2287/* Similar to make_tree_vec, but build on a temporary obstack. */
2288
2289tree
2290make_temp_vec (len)
2291 int len;
2292{
2293 register tree node;
2294 register struct obstack *ambient_obstack = current_obstack;
2295 current_obstack = expression_obstack;
2296 node = make_tree_vec (len);
2297 current_obstack = ambient_obstack;
2298 return node;
2299}
2300
2301/* Build a wrapper around some pointer PTR so we can use it as a tree. */
2302
2303tree
2304build_ptr_wrapper (ptr)
2305 void *ptr;
--- 22 unchanged lines hidden (view full) ---
2328build_int_wrapper (i)
2329 int i;
2330{
2331 tree t = make_node (WRAPPER);
2332 WRAPPER_INT (t) = i;
2333 return t;
2334}
2335
2336tree
2337build_srcloc (file, line)
2338 char *file;
2339 int line;
2340{
2341 tree t;
2342
2343 /* Make sure that we put these on the permanent obstack; up in
2344 add_pending_template, we pass this return value into perm_tree_cons,
--- 28 unchanged lines hidden (view full) ---
2373
2374tree
2375lvalue_type (arg)
2376 tree arg;
2377{
2378 tree type = TREE_TYPE (arg);
2379 if (TREE_CODE (arg) == OVERLOAD)
2380 type = unknown_type_node;
2381 return cp_build_type_variant
2382 (type, TREE_READONLY (arg), TREE_THIS_VOLATILE (arg));
2383}
2384
2385/* The type of ARG for printing error messages; denote lvalues with
2386 reference types. */
2387
2388tree
2389error_type (arg)
2390 tree arg;
--- 26 unchanged lines hidden (view full) ---
2417
2418int
2419member_p (decl)
2420 tree decl;
2421{
2422 tree ctx = DECL_CONTEXT (decl);
2423 return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');
2424}