1/* Language-dependent node constructors for parse phase of GNU compiler.
| 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.
| 2 Copyright (C) 1987, 88, 92-98, 1999 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. 11 12GNU CC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU CC; see the file COPYING. If not, write to 19the Free Software Foundation, 59 Temple Place - Suite 330, 20Boston, MA 02111-1307, USA. */ 21 22#include "config.h" 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
| 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. 11 12GNU CC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU CC; see the file COPYING. If not, write to 19the Free Software Foundation, 59 Temple Place - Suite 330, 20Boston, MA 02111-1307, USA. */ 21 22#include "config.h" 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));
| 31static tree bot_manip PROTO((tree)); 32static tree perm_manip PROTO((tree)); 33static tree build_cplus_array_type_1 PROTO((tree, tree)); 34static void list_hash_add PROTO((int, tree)); 35static int list_hash PROTO((tree, tree, tree));
|
45static tree list_hash_lookup PROTO((int, int, int, int, tree, tree, 46 tree));
| 36static tree list_hash_lookup PROTO((int, tree, tree, tree));
|
47static void propagate_binfo_offsets PROTO((tree, tree));
| 37static void propagate_binfo_offsets PROTO((tree, tree));
|
48static void unshare_base_binfos PROTO((tree));
| |
49static int avoid_overlap PROTO((tree, tree));
| 38static int avoid_overlap PROTO((tree, tree));
|
| 39static int lvalue_p_1 PROTO((tree, int));
|
50static int equal_functions PROTO((tree, tree));
| 40static int equal_functions PROTO((tree, tree));
|
| 41static tree no_linkage_helper PROTO((tree)); 42static tree build_srcloc PROTO((char *, int));
|
51 52#define CEIL(x,y) (((x) + (y) - 1) / (y)) 53
| 43 44#define CEIL(x,y) (((x) + (y) - 1) / (y)) 45
|
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. */
| 46/* Returns non-zero if REF is an lvalue. If 47 TREAT_CLASS_RVALUES_AS_LVALUES is non-zero, rvalues of class type 48 are considered lvalues. */
|
57
| 49
|
58int 59real_lvalue_p (ref)
| 50static int 51lvalue_p_1 (ref, treat_class_rvalues_as_lvalues)
|
60 tree ref;
| 52 tree ref;
|
| 53 int treat_class_rvalues_as_lvalues;
|
61{
| 54{
|
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:
| 55 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE) 56 return 1; 57 58 if (ref == current_class_ptr && flag_this_is_variable <= 0) 59 return 0; 60 61 switch (TREE_CODE (ref)) 62 { 63 /* preincrements and predecrements are valid lvals, provided 64 what they refer to are valid lvals. */ 65 case PREINCREMENT_EXPR: 66 case PREDECREMENT_EXPR: 67 case COMPONENT_REF: 68 case SAVE_EXPR: 69 case UNSAVE_EXPR: 70 case TRY_CATCH_EXPR: 71 case WITH_CLEANUP_EXPR:
|
82 return real_lvalue_p (TREE_OPERAND (ref, 0));
| 72 case REALPART_EXPR: 73 case IMAGPART_EXPR: 74 case NOP_EXPR: 75 return lvalue_p_1 (TREE_OPERAND (ref, 0), 76 treat_class_rvalues_as_lvalues);
|
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:
| 77 78 case STRING_CST: 79 return 1; 80 81 case VAR_DECL: 82 if (TREE_READONLY (ref) && ! TREE_STATIC (ref) 83 && DECL_LANG_SPECIFIC (ref) 84 && DECL_IN_AGGR_P (ref)) 85 return 0; 86 case INDIRECT_REF: 87 case ARRAY_REF: 88 case PARM_DECL: 89 case RESULT_DECL:
|
96 case ERROR_MARK: 97 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 98 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
| 90 if (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;
| 91 return 1; 92 break; 93 94 /* A currently unresolved scope ref. */ 95 case SCOPE_REF: 96 my_friendly_abort (103); 97 case OFFSET_REF: 98 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL) 99 return 1;
|
108 return real_lvalue_p (TREE_OPERAND (ref, 0)) 109 && real_lvalue_p (TREE_OPERAND (ref, 1));
| 100 return (lvalue_p_1 (TREE_OPERAND (ref, 0), 101 treat_class_rvalues_as_lvalues) 102 && lvalue_p_1 (TREE_OPERAND (ref, 1), 103 treat_class_rvalues_as_lvalues));
|
110 break; 111 112 case COND_EXPR:
| 104 break; 105 106 case COND_EXPR:
|
113 return (real_lvalue_p (TREE_OPERAND (ref, 1)) 114 && real_lvalue_p (TREE_OPERAND (ref, 2)));
| 107 return (lvalue_p_1 (TREE_OPERAND (ref, 1), 108 treat_class_rvalues_as_lvalues) 109 && lvalue_p_1 (TREE_OPERAND (ref, 2), 110 treat_class_rvalues_as_lvalues));
|
115 116 case MODIFY_EXPR: 117 return 1; 118 119 case COMPOUND_EXPR:
| 111 112 case MODIFY_EXPR: 113 return 1; 114 115 case COMPOUND_EXPR:
|
120 return real_lvalue_p (TREE_OPERAND (ref, 1));
| 116 return lvalue_p_1 (TREE_OPERAND (ref, 1), 117 treat_class_rvalues_as_lvalues);
|
121 122 case MAX_EXPR: 123 case MIN_EXPR:
| 118 119 case MAX_EXPR: 120 case MIN_EXPR:
|
124 return (real_lvalue_p (TREE_OPERAND (ref, 0)) 125 && real_lvalue_p (TREE_OPERAND (ref, 1)));
| 121 return (lvalue_p_1 (TREE_OPERAND (ref, 0), 122 treat_class_rvalues_as_lvalues) 123 && lvalue_p_1 (TREE_OPERAND (ref, 1), 124 treat_class_rvalues_as_lvalues));
|
126
| 125
|
| 126 case TARGET_EXPR: 127 return treat_class_rvalues_as_lvalues; 128 129 case CALL_EXPR: 130 return (treat_class_rvalues_as_lvalues 131 && IS_AGGR_TYPE (TREE_TYPE (ref))); 132 133 case FUNCTION_DECL: 134 /* All functions (except non-static-member functions) are 135 lvalues. */ 136 return !DECL_NONSTATIC_MEMBER_FUNCTION_P (ref); 137
|
127 default: 128 break; 129 } 130 131 return 0; 132} 133
| 138 default: 139 break; 140 } 141 142 return 0; 143} 144
|
| 145/* Return nonzero if REF is an lvalue valid for this language. 146 Lvalues can be assigned, unless they have TREE_READONLY, or unless 147 they are FUNCTION_DECLs. Lvalues can have their address taken, 148 unless they have DECL_REGISTER. */ 149 150int 151real_lvalue_p (ref) 152 tree ref; 153{ 154 return lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/0); 155} 156
|
134/* This differs from real_lvalue_p in that class rvalues are considered 135 lvalues. */
| 157/* This differs from real_lvalue_p in that class rvalues are considered 158 lvalues. */
|
| 159
|
136int 137lvalue_p (ref) 138 tree ref; 139{
| 160int 161lvalue_p (ref) 162 tree ref; 163{
|
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;
| 164 return lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/1);
|
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;
| 165} 166 167/* Return nonzero if REF is an lvalue valid for this language; 168 otherwise, print an error message and return zero. */ 169 170int 171lvalue_or_else (ref, string) 172 tree ref;
|
228 char *string;
| 173 const 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. 237 TYPE is the type that this initialization should appear to have. 238 239 Build an encapsulation of the initialization to perform 240 and return it so that it can be processed by language-independent 241 and language-specific expression expanders. */ 242 243tree 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)
| 174{ 175 int win = lvalue_p (ref); 176 if (! win) 177 error ("non-lvalue in %s", string); 178 return win; 179} 180 181/* INIT is a CALL_EXPR which needs info about its target. 182 TYPE is the type that this initialization should appear to have. 183 184 Build an encapsulation of the initialization to perform 185 and return it so that it can be processed by language-independent 186 and language-specific expression expanders. */ 187 188tree 189build_cplus_new (type, init) 190 tree type; 191 tree init; 192{ 193 tree slot; 194 tree rval; 195 196 if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
|
252 return init;
| 197 return convert (type, 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); 261 TREE_SIDE_EFFECTS (rval) = 1; 262 263 return rval; 264} 265 266/* Encapsulate the expression INIT in a TARGET_EXPR. */ 267 268tree 269get_target_expr (init) 270 tree init; 271{ 272 tree slot; 273 tree rval; 274 275 slot = build (VAR_DECL, TREE_TYPE (init)); 276 DECL_ARTIFICIAL (slot) = 1; 277 layout_decl (slot, 0); 278 rval = build (TARGET_EXPR, TREE_TYPE (init), slot, init, 279 NULL_TREE, NULL_TREE); 280 TREE_SIDE_EFFECTS (rval) = 1; 281 282 return rval; 283} 284 285/* Recursively search EXP for CALL_EXPRs that need cleanups and replace 286 these CALL_EXPRs with tree nodes that will perform the cleanups. */ 287 288tree 289break_out_cleanups (exp) 290 tree exp; 291{ 292 tree tmp = exp; 293 294 if (TREE_CODE (tmp) == CALL_EXPR 295 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp))) 296 return build_cplus_new (TREE_TYPE (tmp), tmp); 297 298 while (TREE_CODE (tmp) == NOP_EXPR 299 || TREE_CODE (tmp) == CONVERT_EXPR 300 || TREE_CODE (tmp) == NON_LVALUE_EXPR) 301 { 302 if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR 303 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0)))) 304 { 305 TREE_OPERAND (tmp, 0) 306 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)), 307 TREE_OPERAND (tmp, 0)); 308 break; 309 } 310 else 311 tmp = TREE_OPERAND (tmp, 0); 312 } 313 return exp; 314} 315 316/* Recursively perform a preorder search EXP for CALL_EXPRs, making 317 copies where they are found. Returns a deep copy all nodes transitively 318 containing CALL_EXPRs. */ 319 320tree 321break_out_calls (exp) 322 tree exp; 323{ 324 register tree t1, t2 = NULL_TREE; 325 register enum tree_code code; 326 register int changed = 0; 327 register int i; 328 329 if (exp == NULL_TREE) 330 return exp; 331 332 code = TREE_CODE (exp); 333 334 if (code == CALL_EXPR) 335 return copy_node (exp); 336 337 /* Don't try and defeat a save_expr, as it should only be done once. */ 338 if (code == SAVE_EXPR) 339 return exp; 340 341 switch (TREE_CODE_CLASS (code)) 342 { 343 default: 344 abort (); 345 346 case 'c': /* a constant */ 347 case 't': /* a type node */ 348 case 'x': /* something random, like an identifier or an ERROR_MARK. */ 349 return exp; 350 351 case 'd': /* A decl node */ 352#if 0 /* This is bogus. jason 9/21/94 */ 353 354 t1 = break_out_calls (DECL_INITIAL (exp)); 355 if (t1 != DECL_INITIAL (exp)) 356 { 357 exp = copy_node (exp); 358 DECL_INITIAL (exp) = t1; 359 } 360#endif 361 return exp; 362 363 case 'b': /* A block node */ 364 { 365 /* Don't know how to handle these correctly yet. Must do a 366 break_out_calls on all DECL_INITIAL values for local variables, 367 and also break_out_calls on all sub-blocks and sub-statements. */ 368 abort (); 369 } 370 return exp; 371 372 case 'e': /* an expression */ 373 case 'r': /* a reference */ 374 case 's': /* an expression with side effects */ 375 for (i = tree_code_length[(int) code] - 1; i >= 0; i--) 376 { 377 t1 = break_out_calls (TREE_OPERAND (exp, i)); 378 if (t1 != TREE_OPERAND (exp, i)) 379 { 380 exp = copy_node (exp); 381 TREE_OPERAND (exp, i) = t1; 382 } 383 } 384 return exp; 385 386 case '<': /* a comparison expression */ 387 case '2': /* a binary arithmetic expression */ 388 t2 = break_out_calls (TREE_OPERAND (exp, 1)); 389 if (t2 != TREE_OPERAND (exp, 1)) 390 changed = 1; 391 case '1': /* a unary arithmetic expression */ 392 t1 = break_out_calls (TREE_OPERAND (exp, 0)); 393 if (t1 != TREE_OPERAND (exp, 0)) 394 changed = 1; 395 if (changed) 396 { 397 if (tree_code_length[(int) code] == 1) 398 return build1 (code, TREE_TYPE (exp), t1); 399 else 400 return build (code, TREE_TYPE (exp), t1, t2); 401 } 402 return exp; 403 } 404 405} 406 407extern struct obstack *current_obstack; 408extern struct obstack permanent_obstack, class_obstack; 409extern struct obstack *saveable_obstack; 410extern struct obstack *expression_obstack; 411 412/* Here is how primitive or already-canonicalized types' hash 413 codes are made. MUST BE CONSISTENT WITH tree.c !!! */ 414#define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777) 415 416/* Construct, lay out and return the type of methods belonging to class 417 BASETYPE and whose arguments are described by ARGTYPES and whose values 418 are described by RETTYPE. If each type exists already, reuse it. */ 419 420tree 421build_cplus_method_type (basetype, rettype, argtypes) 422 tree basetype, rettype, argtypes; 423{ 424 register tree t; 425 tree ptype; 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))
| 198 199 slot = build (VAR_DECL, type); 200 DECL_ARTIFICIAL (slot) = 1; 201 layout_decl (slot, 0); 202 rval = build (AGGR_INIT_EXPR, type, 203 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot); 204 TREE_SIDE_EFFECTS (rval) = 1; 205 rval = build (TARGET_EXPR, type, slot, rval, NULL_TREE, NULL_TREE); 206 TREE_SIDE_EFFECTS (rval) = 1; 207 208 return rval; 209} 210 211/* Encapsulate the expression INIT in a TARGET_EXPR. */ 212 213tree 214get_target_expr (init) 215 tree init; 216{ 217 tree slot; 218 tree rval; 219 220 slot = build (VAR_DECL, TREE_TYPE (init)); 221 DECL_ARTIFICIAL (slot) = 1; 222 layout_decl (slot, 0); 223 rval = build (TARGET_EXPR, TREE_TYPE (init), slot, init, 224 NULL_TREE, NULL_TREE); 225 TREE_SIDE_EFFECTS (rval) = 1; 226 227 return rval; 228} 229 230/* Recursively search EXP for CALL_EXPRs that need cleanups and replace 231 these CALL_EXPRs with tree nodes that will perform the cleanups. */ 232 233tree 234break_out_cleanups (exp) 235 tree exp; 236{ 237 tree tmp = exp; 238 239 if (TREE_CODE (tmp) == CALL_EXPR 240 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp))) 241 return build_cplus_new (TREE_TYPE (tmp), tmp); 242 243 while (TREE_CODE (tmp) == NOP_EXPR 244 || TREE_CODE (tmp) == CONVERT_EXPR 245 || TREE_CODE (tmp) == NON_LVALUE_EXPR) 246 { 247 if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR 248 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0)))) 249 { 250 TREE_OPERAND (tmp, 0) 251 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)), 252 TREE_OPERAND (tmp, 0)); 253 break; 254 } 255 else 256 tmp = TREE_OPERAND (tmp, 0); 257 } 258 return exp; 259} 260 261/* Recursively perform a preorder search EXP for CALL_EXPRs, making 262 copies where they are found. Returns a deep copy all nodes transitively 263 containing CALL_EXPRs. */ 264 265tree 266break_out_calls (exp) 267 tree exp; 268{ 269 register tree t1, t2 = NULL_TREE; 270 register enum tree_code code; 271 register int changed = 0; 272 register int i; 273 274 if (exp == NULL_TREE) 275 return exp; 276 277 code = TREE_CODE (exp); 278 279 if (code == CALL_EXPR) 280 return copy_node (exp); 281 282 /* Don't try and defeat a save_expr, as it should only be done once. */ 283 if (code == SAVE_EXPR) 284 return exp; 285 286 switch (TREE_CODE_CLASS (code)) 287 { 288 default: 289 abort (); 290 291 case 'c': /* a constant */ 292 case 't': /* a type node */ 293 case 'x': /* something random, like an identifier or an ERROR_MARK. */ 294 return exp; 295 296 case 'd': /* A decl node */ 297#if 0 /* This is bogus. jason 9/21/94 */ 298 299 t1 = break_out_calls (DECL_INITIAL (exp)); 300 if (t1 != DECL_INITIAL (exp)) 301 { 302 exp = copy_node (exp); 303 DECL_INITIAL (exp) = t1; 304 } 305#endif 306 return exp; 307 308 case 'b': /* A block node */ 309 { 310 /* Don't know how to handle these correctly yet. Must do a 311 break_out_calls on all DECL_INITIAL values for local variables, 312 and also break_out_calls on all sub-blocks and sub-statements. */ 313 abort (); 314 } 315 return exp; 316 317 case 'e': /* an expression */ 318 case 'r': /* a reference */ 319 case 's': /* an expression with side effects */ 320 for (i = tree_code_length[(int) code] - 1; i >= 0; i--) 321 { 322 t1 = break_out_calls (TREE_OPERAND (exp, i)); 323 if (t1 != TREE_OPERAND (exp, i)) 324 { 325 exp = copy_node (exp); 326 TREE_OPERAND (exp, i) = t1; 327 } 328 } 329 return exp; 330 331 case '<': /* a comparison expression */ 332 case '2': /* a binary arithmetic expression */ 333 t2 = break_out_calls (TREE_OPERAND (exp, 1)); 334 if (t2 != TREE_OPERAND (exp, 1)) 335 changed = 1; 336 case '1': /* a unary arithmetic expression */ 337 t1 = break_out_calls (TREE_OPERAND (exp, 0)); 338 if (t1 != TREE_OPERAND (exp, 0)) 339 changed = 1; 340 if (changed) 341 { 342 if (tree_code_length[(int) code] == 1) 343 return build1 (code, TREE_TYPE (exp), t1); 344 else 345 return build (code, TREE_TYPE (exp), t1, t2); 346 } 347 return exp; 348 } 349 350} 351 352extern struct obstack *current_obstack; 353extern struct obstack permanent_obstack, class_obstack; 354extern struct obstack *saveable_obstack; 355extern struct obstack *expression_obstack; 356 357/* Here is how primitive or already-canonicalized types' hash 358 codes are made. MUST BE CONSISTENT WITH tree.c !!! */ 359#define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777) 360 361/* Construct, lay out and return the type of methods belonging to class 362 BASETYPE and whose arguments are described by ARGTYPES and whose values 363 are described by RETTYPE. If each type exists already, reuse it. */ 364 365tree 366build_cplus_method_type (basetype, rettype, argtypes) 367 tree basetype, rettype, argtypes; 368{ 369 register tree t; 370 tree ptype; 371 int hashcode; 372 373 /* Make a node of the sort we want. */ 374 t = make_node (METHOD_TYPE); 375 376 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); 377 TREE_TYPE (t) = rettype; 378 if (IS_SIGNATURE (basetype))
|
434 ptype = build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype), 435 TYPE_READONLY (basetype), 436 TYPE_VOLATILE (basetype));
| 379 ptype = build_signature_pointer_type (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; 445 TREE_SIDE_EFFECTS (argtypes) = 1; /* Mark first argtype as "artificial". */ 446 447 /* If we already have such a type, use the old one and free this one. 448 Note that it also frees up the above cons cell if found. */ 449 hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes); 450 t = type_hash_canon (hashcode, t); 451 452 if (TYPE_SIZE (t) == 0) 453 layout_type (t); 454 455 return t; 456} 457 458static tree 459build_cplus_array_type_1 (elt_type, index_type) 460 tree elt_type; 461 tree index_type; 462{ 463 register struct obstack *ambient_obstack = current_obstack; 464 register struct obstack *ambient_saveable_obstack = saveable_obstack; 465 tree t; 466 467 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent, 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
| 380 else 381 ptype = build_pointer_type (basetype); 382 383 /* The actual arglist for this function includes a "hidden" argument 384 which is "this". Put it into the list of argument types. */ 385 386 argtypes = tree_cons (NULL_TREE, ptype, argtypes); 387 TYPE_ARG_TYPES (t) = argtypes; 388 TREE_SIDE_EFFECTS (argtypes) = 1; /* Mark first argtype as "artificial". */ 389 390 /* If we already have such a type, use the old one and free this one. 391 Note that it also frees up the above cons cell if found. */ 392 hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes); 393 t = type_hash_canon (hashcode, t); 394 395 if (TYPE_SIZE (t) == 0) 396 layout_type (t); 397 398 return t; 399} 400 401static tree 402build_cplus_array_type_1 (elt_type, index_type) 403 tree elt_type; 404 tree index_type; 405{ 406 register struct obstack *ambient_obstack = current_obstack; 407 register struct obstack *ambient_saveable_obstack = saveable_obstack; 408 tree t; 409 410 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent, 411 make this permanent too. */ 412 if (TREE_PERMANENT (elt_type) 413 && (index_type == 0 || TREE_PERMANENT (index_type))) 414 { 415 current_obstack = &permanent_obstack; 416 saveable_obstack = &permanent_obstack; 417 } 418
|
476 if (processing_template_decl
| 419 if (processing_template_decl 420 || uses_template_parms (elt_type)
|
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); 485 486 /* Push these needs up so that initialization takes place 487 more easily. */ 488 TYPE_NEEDS_CONSTRUCTING (t) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type)); 489 TYPE_NEEDS_DESTRUCTOR (t) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type)); 490 current_obstack = ambient_obstack; 491 saveable_obstack = ambient_saveable_obstack; 492 return t; 493} 494 495tree 496build_cplus_array_type (elt_type, index_type) 497 tree elt_type; 498 tree index_type; 499{ 500 tree t;
| 421 || uses_template_parms (index_type)) 422 { 423 t = make_node (ARRAY_TYPE); 424 TREE_TYPE (t) = elt_type; 425 TYPE_DOMAIN (t) = index_type; 426 } 427 else 428 t = build_array_type (elt_type, index_type); 429 430 /* Push these needs up so that initialization takes place 431 more easily. */ 432 TYPE_NEEDS_CONSTRUCTING (t) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type)); 433 TYPE_NEEDS_DESTRUCTOR (t) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type)); 434 current_obstack = ambient_obstack; 435 saveable_obstack = ambient_saveable_obstack; 436 return t; 437} 438 439tree 440build_cplus_array_type (elt_type, index_type) 441 tree elt_type; 442 tree index_type; 443{ 444 tree t;
|
501 int constp = TYPE_READONLY (elt_type); 502 int volatilep = TYPE_VOLATILE (elt_type);
| 445 int type_quals = CP_TYPE_QUALS (elt_type); 446
|
503 elt_type = TYPE_MAIN_VARIANT (elt_type); 504 505 t = build_cplus_array_type_1 (elt_type, index_type); 506
| 447 elt_type = TYPE_MAIN_VARIANT (elt_type); 448 449 t = build_cplus_array_type_1 (elt_type, index_type); 450
|
507 if (constp || volatilep) 508 t = cp_build_type_variant (t, constp, volatilep);
| 451 if (type_quals != TYPE_UNQUALIFIED) 452 t = cp_build_qualified_type (t, type_quals);
|
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
| 453 454 return t; 455} 456 457/* Make a variant type in the proper way for C/C++, propagating qualifiers 458 down to the element type of an array. */ 459 460tree
|
517cp_build_type_variant (type, constp, volatilep)
| 461cp_build_qualified_type (type, type_quals)
|
518 tree type;
| 462 tree type;
|
519 int constp, volatilep;
| 463 int type_quals;
|
520{ 521 if (type == error_mark_node) 522 return type; 523
| 464{ 465 if (type == error_mark_node) 466 return type; 467
|
| 468 /* A restrict-qualified pointer type must be a pointer (or reference) 469 to object or incomplete type. */ 470 if ((type_quals & TYPE_QUAL_RESTRICT) 471 && (!POINTER_TYPE_P (type) 472 || TYPE_PTRMEM_P (type) 473 || TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)) 474 { 475 cp_error ("`%T' cannot be `restrict'-qualified", type); 476 type_quals &= ~TYPE_QUAL_RESTRICT; 477 } 478
|
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));
| 479 if (TREE_CODE (type) == ARRAY_TYPE) 480 { 481 tree real_main_variant = TYPE_MAIN_VARIANT (type); 482 483 push_obstacks (TYPE_OBSTACK (real_main_variant), 484 TYPE_OBSTACK (real_main_variant));
|
530 type = build_cplus_array_type_1 (cp_build_type_variant 531 (TREE_TYPE (type), constp, volatilep),
| 485 type = build_cplus_array_type_1 (cp_build_qualified_type 486 (TREE_TYPE (type), type_quals),
|
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 }
| 487 TYPE_DOMAIN (type)); 488 489 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not, 490 make a copy. (TYPE might have come from the hash table and 491 REAL_MAIN_VARIANT might be in some function's obstack.) */ 492 493 if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant)) 494 { 495 type = copy_node (type); 496 TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0; 497 } 498 499 TYPE_MAIN_VARIANT (type) = real_main_variant; 500 pop_obstacks (); 501 return type; 502 }
|
548 return build_type_variant (type, constp, volatilep);
| 503 return build_qualified_type (type, type_quals);
|
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{
| 504} 505 506/* Returns the canonical version of TYPE. In other words, if TYPE is 507 a typedef, returns the underlying type. The cv-qualification of 508 the type returned matches the type input; they will always be 509 compatible types. */ 510 511tree 512canonical_type_variant (t) 513 tree t; 514{
|
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);
| 515 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), CP_TYPE_QUALS (t));
|
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. */ 580 581static void 582propagate_binfo_offsets (binfo, offset) 583 tree binfo; 584 tree offset; 585{ 586 tree binfos = BINFO_BASETYPES (binfo); 587 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; 588 589 for (i = 0; i < n_baselinks; /* note increment is done in the loop. */) 590 { 591 tree base_binfo = TREE_VEC_ELT (binfos, i); 592 593 if (TREE_VIA_VIRTUAL (base_binfo)) 594 i += 1; 595 else 596 { 597 int j; 598 tree delta = NULL_TREE; 599 600 for (j = i+1; j < n_baselinks; j++) 601 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j))) 602 { 603 /* The next basetype offset must take into account the space 604 between the classes, not just the size of each class. */ 605 delta = size_binop (MINUS_EXPR, 606 BINFO_OFFSET (TREE_VEC_ELT (binfos, j)), 607 BINFO_OFFSET (base_binfo)); 608 break; 609 } 610 611#if 0 612 if (BINFO_OFFSET_ZEROP (base_binfo)) 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
| 516} 517 518/* Add OFFSET to all base types of T. 519 520 OFFSET, which is a type offset, is number of bytes. 521 522 Note that we don't have to worry about having two paths to the 523 same base type, since this type owns its association list. */ 524 525static void 526propagate_binfo_offsets (binfo, offset) 527 tree binfo; 528 tree offset; 529{ 530 tree binfos = BINFO_BASETYPES (binfo); 531 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; 532 533 for (i = 0; i < n_baselinks; /* note increment is done in the loop. */) 534 { 535 tree base_binfo = TREE_VEC_ELT (binfos, i); 536 537 if (TREE_VIA_VIRTUAL (base_binfo)) 538 i += 1; 539 else 540 { 541 int j; 542 tree delta = NULL_TREE; 543 544 for (j = i+1; j < n_baselinks; j++) 545 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j))) 546 { 547 /* The next basetype offset must take into account the space 548 between the classes, not just the size of each class. */ 549 delta = size_binop (MINUS_EXPR, 550 BINFO_OFFSET (TREE_VEC_ELT (binfos, j)), 551 BINFO_OFFSET (base_binfo)); 552 break; 553 } 554 555#if 0 556 if (BINFO_OFFSET_ZEROP (base_binfo)) 557 BINFO_OFFSET (base_binfo) = offset; 558 else 559 BINFO_OFFSET (base_binfo) 560 = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset); 561#else 562 BINFO_OFFSET (base_binfo) = offset; 563#endif 564
|
621 unshare_base_binfos (base_binfo);
| 565 propagate_binfo_offsets (base_binfo, offset);
|
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
| 566 567 /* Go to our next class that counts for offset propagation. */ 568 i = j; 569 if (i < n_baselinks) 570 offset = size_binop (PLUS_EXPR, offset, delta); 571 } 572 } 573} 574
|
631/* Makes new binfos for the indirect bases under BASE_BINFO, and updates
| 575/* Makes new binfos for the indirect bases under BINFO, and updates
|
632 BINFO_OFFSET for them and their bases. */ 633
| 576 BINFO_OFFSET for them and their bases. */ 577
|
634static void 635unshare_base_binfos (base_binfo) 636 tree base_binfo;
| 578void 579unshare_base_binfos (binfo) 580 tree binfo;
|
637{
| 581{
|
638 if (BINFO_BASETYPES (base_binfo)) 639 { 640 tree base_binfos = BINFO_BASETYPES (base_binfo); 641 tree chain = NULL_TREE; 642 int j;
| 582 tree binfos = BINFO_BASETYPES (binfo); 583 tree new_binfo; 584 int j;
|
643
| 585
|
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 }
| 586 if (binfos == NULL_TREE) 587 return;
|
661
| 588
|
662 /* Completely unshare potentially shared data, and 663 update what is ours. */ 664 propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
| 589 /* Now unshare the structure beneath BINFO. */ 590 for (j = TREE_VEC_LENGTH (binfos)-1; 591 j >= 0; j--) 592 { 593 tree base_binfo = TREE_VEC_ELT (binfos, j); 594 new_binfo = TREE_VEC_ELT (binfos, j) 595 = make_binfo (BINFO_OFFSET (base_binfo), 596 base_binfo, 597 BINFO_VTABLE (base_binfo), 598 BINFO_VIRTUALS (base_binfo)); 599 TREE_VIA_PUBLIC (new_binfo) = TREE_VIA_PUBLIC (base_binfo); 600 TREE_VIA_PROTECTED (new_binfo) = TREE_VIA_PROTECTED (base_binfo); 601 TREE_VIA_VIRTUAL (new_binfo) = TREE_VIA_VIRTUAL (base_binfo); 602 BINFO_INHERITANCE_CHAIN (new_binfo) = binfo; 603 unshare_base_binfos (new_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
| 604 } 605} 606 607/* Finish the work of layout_record, now taking virtual bases into account. 608 Also compute the actual offsets that our base classes will have. 609 This must be performed after the fields are laid out, since virtual 610 baseclasses must lay down at the end of the record. 611 612 Returns the maximum number of virtual functions any of the 613 baseclasses provide. */ 614 615int 616layout_basetypes (rec, max) 617 tree rec; 618 int max; 619{ 620 tree binfos = TYPE_BINFO_BASETYPES (rec); 621 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; 622
|
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);
| 623 tree vbase_types;
|
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
| 624 625 unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec)); 626 unsigned int desired_align; 627 628 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */ 629 register unsigned int const_size = 0; 630 unsigned int nonvirtual_const_size; 631 632#ifdef STRUCTURE_SIZE_BOUNDARY 633 /* Packed structures don't need to have minimum size. */ 634 if (! TYPE_PACKED (rec)) 635 record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY); 636#endif 637
|
701 CLASSTYPE_VBASECLASSES (rec) = vbase_types;
| 638 /* Get all the virtual base types that this type uses. The 639 TREE_VALUE slot holds the virtual baseclass type. Note that 640 get_vbase_types makes copies of the virtual base BINFOs, so that 641 the vbase_types are unshared. */ 642 vbase_types = CLASSTYPE_VBASECLASSES (rec);
|
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 { 710 tree basetype = BINFO_TYPE (vbase_types); 711 tree offset; 712 713 desired_align = TYPE_ALIGN (basetype); 714 record_align = MAX (record_align, desired_align); 715 716 if (const_size == 0) 717 offset = integer_zero_node; 718 else 719 { 720 /* Give each virtual base type the alignment it wants. */ 721 const_size = CEIL (const_size, desired_align) * desired_align; 722 offset = size_int (CEIL (const_size, BITS_PER_UNIT)); 723 } 724 725 if (CLASSTYPE_VSIZE (basetype) > max) 726 max = CLASSTYPE_VSIZE (basetype); 727 BINFO_OFFSET (vbase_types) = offset; 728 729 /* Every virtual baseclass takes a least a UNIT, so that we can 730 take it's address and get something different for each base. */ 731 const_size += MAX (BITS_PER_UNIT, 732 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype))); 733 734 vbase_types = TREE_CHAIN (vbase_types); 735 } 736 737 if (const_size) 738 { 739 /* Because a virtual base might take a single byte above, 740 we have to re-adjust the total size to make sure it is 741 a multiple of the alignment. */ 742 /* Give the whole object the alignment it wants. */ 743 const_size = CEIL (const_size, record_align) * record_align; 744 } 745 746 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN 747 here, as that is for this class, without any virtual base classes. */ 748 TYPE_ALIGN (rec) = record_align; 749 if (const_size != nonvirtual_const_size) 750 { 751 TYPE_SIZE (rec) = size_int (const_size); 752 TYPE_SIZE_UNIT (rec) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rec), 753 size_int (BITS_PER_UNIT)); 754 } 755 756 /* Now propagate offset information throughout the lattice. */ 757 for (i = 0; i < n_baseclasses; i++) 758 { 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);
| 643 644 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST, 19970302); 645 const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec)); 646 647 nonvirtual_const_size = const_size; 648 649 while (vbase_types) 650 { 651 tree basetype = BINFO_TYPE (vbase_types); 652 tree offset; 653 654 desired_align = TYPE_ALIGN (basetype); 655 record_align = MAX (record_align, desired_align); 656 657 if (const_size == 0) 658 offset = integer_zero_node; 659 else 660 { 661 /* Give each virtual base type the alignment it wants. */ 662 const_size = CEIL (const_size, desired_align) * desired_align; 663 offset = size_int (CEIL (const_size, BITS_PER_UNIT)); 664 } 665 666 if (CLASSTYPE_VSIZE (basetype) > max) 667 max = CLASSTYPE_VSIZE (basetype); 668 BINFO_OFFSET (vbase_types) = offset; 669 670 /* Every virtual baseclass takes a least a UNIT, so that we can 671 take it's address and get something different for each base. */ 672 const_size += MAX (BITS_PER_UNIT, 673 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype))); 674 675 vbase_types = TREE_CHAIN (vbase_types); 676 } 677 678 if (const_size) 679 { 680 /* Because a virtual base might take a single byte above, 681 we have to re-adjust the total size to make sure it is 682 a multiple of the alignment. */ 683 /* Give the whole object the alignment it wants. */ 684 const_size = CEIL (const_size, record_align) * record_align; 685 } 686 687 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN 688 here, as that is for this class, without any virtual base classes. */ 689 TYPE_ALIGN (rec) = record_align; 690 if (const_size != nonvirtual_const_size) 691 { 692 TYPE_SIZE (rec) = size_int (const_size); 693 TYPE_SIZE_UNIT (rec) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rec), 694 size_int (BITS_PER_UNIT)); 695 } 696 697 /* Now propagate offset information throughout the lattice. */ 698 for (i = 0; i < n_baseclasses; i++) 699 { 700 register tree base_binfo = TREE_VEC_ELT (binfos, i); 701 register tree basetype = BINFO_TYPE (base_binfo); 702 tree field = TYPE_FIELDS (rec); 703 704 if (TREE_VIA_VIRTUAL (base_binfo)) 705 continue; 706 707 my_friendly_assert (TREE_TYPE (field) == basetype, 23897);
|
| 708 709 if (get_base_distance (basetype, rec, 0, (tree*)0) == -2) 710 cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity", 711 basetype, rec); 712
|
767 BINFO_OFFSET (base_binfo) 768 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)), 769 BITS_PER_UNIT));
| 713 BINFO_OFFSET (base_binfo) 714 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)), 715 BITS_PER_UNIT));
|
770 unshare_base_binfos (base_binfo);
| 716 propagate_binfo_offsets (base_binfo, BINFO_OFFSET (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);
| 717 TYPE_FIELDS (rec) = TREE_CHAIN (field); 718 } 719 720 for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types; 721 vbase_types = TREE_CHAIN (vbase_types)) 722 { 723 BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec); 724 unshare_base_binfos (vbase_types);
|
| 725 propagate_binfo_offsets (vbase_types, BINFO_OFFSET (vbase_types)); 726 727 if (extra_warnings) 728 { 729 tree basetype = BINFO_TYPE (vbase_types); 730 if (get_base_distance (basetype, rec, 0, (tree*)0) == -2) 731 cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity", 732 basetype, rec); 733 }
|
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, 787 return 0. */ 788 789static int 790avoid_overlap (decl, newdecl) 791 tree decl, newdecl; 792{ 793 tree field; 794 795 if (newdecl == NULL_TREE 796 || ! types_overlap_p (TREE_TYPE (decl), TREE_TYPE (newdecl))) 797 return 0; 798 799 for (field = decl; TREE_CHAIN (field) && TREE_CHAIN (field) != newdecl; 800 field = TREE_CHAIN (field)) 801 ; 802 803 DECL_SIZE (field) = integer_one_node; 804 805 return 1; 806} 807 808/* Returns a list of fields to stand in for the base class subobjects 809 of REC. These fields are later removed by layout_basetypes. */ 810 811tree 812build_base_fields (rec) 813 tree rec; 814{ 815 /* Chain to hold all the new FIELD_DECLs which stand in for base class 816 subobjects. */ 817 tree base_decls = NULL_TREE; 818 tree binfos = TYPE_BINFO_BASETYPES (rec); 819 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; 820 tree decl, nextdecl; 821 int i, saw_empty = 0; 822 unsigned int base_align = 0; 823 824 for (i = 0; i < n_baseclasses; ++i) 825 { 826 register tree base_binfo = TREE_VEC_ELT (binfos, i); 827 register tree basetype = BINFO_TYPE (base_binfo); 828 829 if (TYPE_SIZE (basetype) == 0) 830 /* This error is now reported in xref_tag, thus giving better 831 location information. */ 832 continue; 833 834 if (TREE_VIA_VIRTUAL (base_binfo)) 835 continue; 836 837 decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, basetype); 838 DECL_ARTIFICIAL (decl) = 1; 839 DECL_FIELD_CONTEXT (decl) = DECL_CLASS_CONTEXT (decl) = rec; 840 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype); 841 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype); 842 TREE_CHAIN (decl) = base_decls; 843 base_decls = decl; 844 845 if (! flag_new_abi) 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)),
| 734 } 735 736 return max; 737} 738 739/* If the empty base field in DECL overlaps with a base of the same type in 740 NEWDECL, which is either another base field or the first data field of 741 the class, pad the base just before NEWDECL and return 1. Otherwise, 742 return 0. */ 743 744static int 745avoid_overlap (decl, newdecl) 746 tree decl, newdecl; 747{ 748 tree field; 749 750 if (newdecl == NULL_TREE 751 || ! types_overlap_p (TREE_TYPE (decl), TREE_TYPE (newdecl))) 752 return 0; 753 754 for (field = decl; TREE_CHAIN (field) && TREE_CHAIN (field) != newdecl; 755 field = TREE_CHAIN (field)) 756 ; 757 758 DECL_SIZE (field) = integer_one_node; 759 760 return 1; 761} 762 763/* Returns a list of fields to stand in for the base class subobjects 764 of REC. These fields are later removed by layout_basetypes. */ 765 766tree 767build_base_fields (rec) 768 tree rec; 769{ 770 /* Chain to hold all the new FIELD_DECLs which stand in for base class 771 subobjects. */ 772 tree base_decls = NULL_TREE; 773 tree binfos = TYPE_BINFO_BASETYPES (rec); 774 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; 775 tree decl, nextdecl; 776 int i, saw_empty = 0; 777 unsigned int base_align = 0; 778 779 for (i = 0; i < n_baseclasses; ++i) 780 { 781 register tree base_binfo = TREE_VEC_ELT (binfos, i); 782 register tree basetype = BINFO_TYPE (base_binfo); 783 784 if (TYPE_SIZE (basetype) == 0) 785 /* This error is now reported in xref_tag, thus giving better 786 location information. */ 787 continue; 788 789 if (TREE_VIA_VIRTUAL (base_binfo)) 790 continue; 791 792 decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, basetype); 793 DECL_ARTIFICIAL (decl) = 1; 794 DECL_FIELD_CONTEXT (decl) = DECL_CLASS_CONTEXT (decl) = rec; 795 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype); 796 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype); 797 TREE_CHAIN (decl) = base_decls; 798 base_decls = decl; 799 800 if (! flag_new_abi) 801 { 802 /* Brain damage for backwards compatibility. For no good reason, 803 the old layout_basetypes made every base at least as large as 804 the alignment for the bases up to that point, gratuitously 805 wasting space. So we do the same thing here. */ 806 base_align = MAX (base_align, DECL_ALIGN (decl)); 807 DECL_SIZE (decl) 808 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
|
854 base_align));
| 809 (int) 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); 863 864 /* In the presence of empty base classes, we run the risk of allocating 865 two objects of the same class on top of one another. Avoid that. */ 866 if (flag_new_abi && saw_empty) 867 for (decl = base_decls; decl; decl = TREE_CHAIN (decl)) 868 { 869 if (DECL_SIZE (decl) == integer_zero_node) 870 { 871 /* First step through the following bases until we find 872 an overlap or a non-empty base. */ 873 for (nextdecl = TREE_CHAIN (decl); nextdecl; 874 nextdecl = TREE_CHAIN (nextdecl)) 875 { 876 if (avoid_overlap (decl, nextdecl) 877 || DECL_SIZE (nextdecl) != integer_zero_node) 878 goto nextbase; 879 } 880 881 /* If we're still looking, also check against the first 882 field. */ 883 for (nextdecl = TYPE_FIELDS (rec); 884 nextdecl && TREE_CODE (nextdecl) != FIELD_DECL; 885 nextdecl = TREE_CHAIN (nextdecl)) 886 /* keep looking */; 887 avoid_overlap (decl, nextdecl); 888 } 889 nextbase:; 890 } 891 892 return base_decls; 893} 894 895/* Returns list of virtual base class pointers in a FIELD_DECL chain. */ 896 897tree 898build_vbase_pointer_fields (rec) 899 tree rec; 900{ 901 /* Chain to hold all the new FIELD_DECLs which point at virtual 902 base classes. */ 903 tree vbase_decls = NULL_TREE; 904 tree binfos = TYPE_BINFO_BASETYPES (rec); 905 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; 906 tree decl; 907 int i; 908 909 /* Handle basetypes almost like fields, but record their 910 offsets differently. */ 911 912 for (i = 0; i < n_baseclasses; i++) 913 { 914 register tree base_binfo = TREE_VEC_ELT (binfos, i); 915 register tree basetype = BINFO_TYPE (base_binfo); 916 917 if (TYPE_SIZE (basetype) == 0) 918 /* This error is now reported in xref_tag, thus giving better 919 location information. */ 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;
| 810 } 811 else if (DECL_SIZE (decl) == integer_zero_node) 812 saw_empty = 1; 813 } 814 815 /* Reverse the list of fields so we allocate the bases in the proper 816 order. */ 817 base_decls = nreverse (base_decls); 818 819 /* In the presence of empty base classes, we run the risk of allocating 820 two objects of the same class on top of one another. Avoid that. */ 821 if (flag_new_abi && saw_empty) 822 for (decl = base_decls; decl; decl = TREE_CHAIN (decl)) 823 { 824 if (DECL_SIZE (decl) == integer_zero_node) 825 { 826 /* First step through the following bases until we find 827 an overlap or a non-empty base. */ 828 for (nextdecl = TREE_CHAIN (decl); nextdecl; 829 nextdecl = TREE_CHAIN (nextdecl)) 830 { 831 if (avoid_overlap (decl, nextdecl) 832 || DECL_SIZE (nextdecl) != integer_zero_node) 833 goto nextbase; 834 } 835 836 /* If we're still looking, also check against the first 837 field. */ 838 for (nextdecl = TYPE_FIELDS (rec); 839 nextdecl && TREE_CODE (nextdecl) != FIELD_DECL; 840 nextdecl = TREE_CHAIN (nextdecl)) 841 /* keep looking */; 842 avoid_overlap (decl, nextdecl); 843 } 844 nextbase:; 845 } 846 847 return base_decls; 848} 849 850/* Returns list of virtual base class pointers in a FIELD_DECL chain. */ 851 852tree 853build_vbase_pointer_fields (rec) 854 tree rec; 855{ 856 /* Chain to hold all the new FIELD_DECLs which point at virtual 857 base classes. */ 858 tree vbase_decls = NULL_TREE; 859 tree binfos = TYPE_BINFO_BASETYPES (rec); 860 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; 861 tree decl; 862 int i; 863 864 /* Handle basetypes almost like fields, but record their 865 offsets differently. */ 866 867 for (i = 0; i < n_baseclasses; i++) 868 { 869 register tree base_binfo = TREE_VEC_ELT (binfos, i); 870 register tree basetype = BINFO_TYPE (base_binfo); 871 872 if (TYPE_SIZE (basetype) == 0) 873 /* This error is now reported in xref_tag, thus giving better 874 location information. */ 875 continue; 876 877 /* All basetypes are recorded in the association list of the 878 derived type. */ 879 880 if (TREE_VIA_VIRTUAL (base_binfo)) 881 { 882 int j;
|
928 char *name = (char *)alloca (TYPE_NAME_LENGTH (basetype) 929 + sizeof (VBASE_NAME) + 1);
| 883 const char *name;
|
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 }
| 884 885 /* The offset for a virtual base class is only used in computing 886 virtual function tables and for initializing virtual base 887 pointers. It is built once `get_vbase_types' is called. */ 888 889 /* If this basetype can come from another vbase pointer 890 without an additional indirection, we will share 891 that pointer. If an indirection is involved, we 892 make our own pointer. */ 893 for (j = 0; j < n_baseclasses; j++) 894 { 895 tree other_base_binfo = TREE_VEC_ELT (binfos, j); 896 if (! TREE_VIA_VIRTUAL (other_base_binfo) 897 && binfo_member (basetype, 898 CLASSTYPE_VBASECLASSES (BINFO_TYPE 899 (other_base_binfo)) 900 )) 901 goto got_it; 902 }
|
949 sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (basetype));
| 903 FORMAT_VBASE_NAME (name, 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; 958 DECL_FIELD_CONTEXT (decl) = rec; 959 DECL_CLASS_CONTEXT (decl) = rec; 960 DECL_FCONTEXT (decl) = basetype; 961 DECL_SAVED_INSNS (decl) = NULL_RTX; 962 DECL_FIELD_SIZE (decl) = 0; 963 DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node); 964 TREE_CHAIN (decl) = vbase_decls; 965 BINFO_VPTR_FIELD (base_binfo) = decl; 966 vbase_decls = decl; 967 968 got_it: 969 /* The space this decl occupies has already been accounted for. */ 970 ; 971 } 972 } 973 974 return vbase_decls; 975} 976 977/* Hashing of lists so that we don't make duplicates. 978 The entry point is `list_hash_canon'. */ 979 980/* Each hash table slot is a bucket containing a chain 981 of these structures. */ 982 983struct list_hash 984{ 985 struct list_hash *next; /* Next structure in the bucket. */ 986 int hashcode; /* Hash code of this list. */ 987 tree list; /* The list recorded here. */ 988}; 989 990/* Now here is the hash table. When recording a list, it is added 991 to the slot whose index is the hash code mod the table size. 992 Note that the hash table is used for several kinds of lists. 993 While all these live in the same table, they are completely independent, 994 and the hash code is computed differently for each of these. */ 995 996#define TYPE_HASH_SIZE 59 997static struct list_hash *list_hash_table[TYPE_HASH_SIZE]; 998 999/* Compute a hash code for a list (chain of TREE_LIST nodes 1000 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the 1001 TREE_COMMON slots), by adding the hash codes of the individual entries. */ 1002 1003static int 1004list_hash (purpose, value, chain) 1005 tree purpose, value, chain; 1006{ 1007 register int hashcode = 0; 1008 1009 if (chain) 1010 hashcode += TYPE_HASH (chain); 1011 1012 if (value) 1013 hashcode += TYPE_HASH (value); 1014 else 1015 hashcode += 1007; 1016 if (purpose) 1017 hashcode += TYPE_HASH (purpose); 1018 else 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
| 904 decl = build_lang_field_decl (FIELD_DECL, get_identifier (name), 905 build_pointer_type (basetype)); 906 /* If you change any of the below, take a look at all the 907 other VFIELD_BASEs and VTABLE_BASEs in the code, and change 908 them too. */ 909 DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE); 910 DECL_VIRTUAL_P (decl) = 1; 911 DECL_ARTIFICIAL (decl) = 1; 912 DECL_FIELD_CONTEXT (decl) = rec; 913 DECL_CLASS_CONTEXT (decl) = rec; 914 DECL_FCONTEXT (decl) = basetype; 915 DECL_SAVED_INSNS (decl) = NULL_RTX; 916 DECL_FIELD_SIZE (decl) = 0; 917 DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node); 918 TREE_CHAIN (decl) = vbase_decls; 919 BINFO_VPTR_FIELD (base_binfo) = decl; 920 vbase_decls = decl; 921 922 got_it: 923 /* The space this decl occupies has already been accounted for. */ 924 ; 925 } 926 } 927 928 return vbase_decls; 929} 930 931/* Hashing of lists so that we don't make duplicates. 932 The entry point is `list_hash_canon'. */ 933 934/* Each hash table slot is a bucket containing a chain 935 of these structures. */ 936 937struct list_hash 938{ 939 struct list_hash *next; /* Next structure in the bucket. */ 940 int hashcode; /* Hash code of this list. */ 941 tree list; /* The list recorded here. */ 942}; 943 944/* Now here is the hash table. When recording a list, it is added 945 to the slot whose index is the hash code mod the table size. 946 Note that the hash table is used for several kinds of lists. 947 While all these live in the same table, they are completely independent, 948 and the hash code is computed differently for each of these. */ 949 950#define TYPE_HASH_SIZE 59 951static struct list_hash *list_hash_table[TYPE_HASH_SIZE]; 952 953/* Compute a hash code for a list (chain of TREE_LIST nodes 954 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the 955 TREE_COMMON slots), by adding the hash codes of the individual entries. */ 956 957static int 958list_hash (purpose, value, chain) 959 tree purpose, value, chain; 960{ 961 register int hashcode = 0; 962 963 if (chain) 964 hashcode += TYPE_HASH (chain); 965 966 if (value) 967 hashcode += TYPE_HASH (value); 968 else 969 hashcode += 1007; 970 if (purpose) 971 hashcode += TYPE_HASH (purpose); 972 else 973 hashcode += 1009; 974 return hashcode; 975} 976 977/* Look in the type hash table for a type isomorphic to TYPE. 978 If one is found, return it. Otherwise return 0. */ 979 980static tree
|
1027list_hash_lookup (hashcode, via_public, via_protected, via_virtual, 1028 purpose, value, chain) 1029 int hashcode, via_public, via_virtual, via_protected;
| 981list_hash_lookup (hashcode, purpose, value, chain) 982 int hashcode;
|
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
| 983 tree purpose, value, chain; 984{ 985 register struct list_hash *h; 986 987 for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next) 988 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 1047 for a list TYPE whose hash code is HASHCODE. */ 1048 1049static void 1050list_hash_add (hashcode, list) 1051 int hashcode; 1052 tree list; 1053{ 1054 register struct list_hash *h; 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
| 989 && TREE_PURPOSE (h->list) == purpose 990 && TREE_VALUE (h->list) == value 991 && TREE_CHAIN (h->list) == chain) 992 return h->list; 993 return 0; 994} 995 996/* Add an entry to the list-hash-table 997 for a list TYPE whose hash code is HASHCODE. */ 998 999static void 1000list_hash_add (hashcode, list) 1001 int hashcode; 1002 tree list; 1003{ 1004 register struct list_hash *h; 1005 1006 h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash)); 1007 h->hashcode = hashcode; 1008 h->list = list; 1009 h->next = list_hash_table[hashcode % TYPE_HASH_SIZE]; 1010 list_hash_table[hashcode % TYPE_HASH_SIZE] = h; 1011} 1012
|
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.
| 1013/* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical 1014 object for an identical list if one already exists. Otherwise, build a 1015 new one, and record it as the canonical object. */
|
1067
| 1016
|
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
| 1017/* Set to 1 to debug without canonicalization. Never set by program. */ 1018 1019static int debug_no_list_hash = 0; 1020 1021tree
|
1079hash_tree_cons (via_public, via_virtual, via_protected, purpose, value, chain) 1080 int via_public, via_virtual, via_protected;
| 1022hash_tree_cons (purpose, value, chain)
|
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);
| 1023 tree purpose, value, chain; 1024{ 1025 struct obstack *ambient_obstack = current_obstack; 1026 tree t; 1027 int hashcode = 0; 1028 1029 if (! debug_no_list_hash) 1030 { 1031 hashcode = list_hash (purpose, value, chain);
|
1090 t = list_hash_lookup (hashcode, via_public, via_protected, via_virtual, 1091 purpose, value, chain);
| 1032 t = list_hash_lookup (hashcode, purpose, value, chain);
|
1092 if (t) 1093 return t; 1094 } 1095 1096 current_obstack = &class_obstack; 1097 1098 t = tree_cons (purpose, value, chain);
| 1033 if (t) 1034 return t; 1035 } 1036 1037 current_obstack = &class_obstack; 1038 1039 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{
| 1040 1041 /* If this is a new list, record it for later reuse. */ 1042 if (! debug_no_list_hash) 1043 list_hash_add (hashcode, t); 1044 1045 current_obstack = ambient_obstack; 1046 return t; 1047} 1048 1049/* Constructor for hashed lists. */ 1050 1051tree 1052hash_tree_chain (value, chain) 1053 tree value, chain; 1054{
|
1117 return hash_tree_cons (0, 0, 0, NULL_TREE, value, chain);
| 1055 return hash_tree_cons (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}
| 1056} 1057 1058/* Similar, but used for concatenating two lists. */ 1059 1060tree 1061hash_chainon (list1, list2) 1062 tree list1, list2; 1063{ 1064 if (list2 == 0) 1065 return list1; 1066 if (list1 == 0) 1067 return list2; 1068 if (TREE_CHAIN (list1) == NULL_TREE) 1069 return hash_tree_chain (TREE_VALUE (list1), list2); 1070 return hash_tree_chain (TREE_VALUE (list1), 1071 hash_chainon (TREE_CHAIN (list1), list2)); 1072}
|
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
| 1073 1074/* Build an association between TYPE and some parameters: 1075 1076 OFFSET is the offset added to `this' to convert it to a pointer 1077 of type `TYPE *' 1078 1079 BINFO is the base binfo to use, if we are deriving from one. This 1080 is necessary, as we want specialized parent binfos from base 1081 classes, so that the VTABLE_NAMEs of bases are for the most derived 1082 type, instead of the simple type. 1083 1084 VTABLE is the virtual function table with which to initialize 1085 sub-objects of type TYPE. 1086
|
1203 VIRTUALS are the virtual functions sitting in VTABLE.
| 1087 VIRTUALS are the virtual functions sitting in VTABLE. */
|
1204
| 1088
|
1205 CHAIN are more associations we must retain. */ 1206
| |
1207tree
| 1089tree
|
1208make_binfo (offset, binfo, vtable, virtuals, chain)
| 1090make_binfo (offset, binfo, vtable, virtuals)
|
1209 tree offset, binfo; 1210 tree vtable, virtuals;
| 1091 tree offset, binfo; 1092 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;
| 1093{ 1094 tree new_binfo = make_tree_vec (7); 1095 tree type; 1096 1097 if (TREE_CODE (binfo) == TREE_VEC) 1098 type = BINFO_TYPE (binfo); 1099 else 1100 { 1101 type = binfo;
|
1221 binfo = TYPE_BINFO (binfo);
| 1102 binfo = CLASS_TYPE_P (type) ? TYPE_BINFO (binfo) : NULL_TREE;
|
1222 } 1223
| 1103 } 1104
|
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)); 1236 return new_binfo; 1237} 1238 1239/* Return the binfo value for ELEM in TYPE. */ 1240 1241tree 1242binfo_value (elem, type) 1243 tree elem; 1244 tree type; 1245{ 1246 if (get_base_distance (elem, type, 0, (tree *)0) == -2) 1247 compiler_error ("base class `%s' ambiguous in binfo_value", 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
| 1105 TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type); 1106 BINFO_OFFSET (new_binfo) = offset; 1107 BINFO_VTABLE (new_binfo) = vtable; 1108 BINFO_VIRTUALS (new_binfo) = virtuals; 1109 BINFO_VPTR_FIELD (new_binfo) = NULL_TREE; 1110 1111 if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE) 1112 BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo)); 1113 return new_binfo; 1114} 1115 1116/* Return the binfo value for ELEM in TYPE. */ 1117 1118tree 1119binfo_value (elem, type) 1120 tree elem; 1121 tree type; 1122{ 1123 if (get_base_distance (elem, type, 0, (tree *)0) == -2) 1124 compiler_error ("base class `%s' ambiguous in binfo_value", 1125 TYPE_NAME_STRING (elem)); 1126 if (elem == type) 1127 return TYPE_BINFO (type); 1128 if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type) 1129 return type; 1130 return get_binfo (elem, type, 0); 1131} 1132
|
| 1133/* Return a reversed copy of the BINFO-chain given by PATH. (If the 1134 BINFO_INHERITANCE_CHAIN points from base classes to derived 1135 classes, it will instead point from derived classes to base 1136 classes.) Returns the first node in the reversed chain. */ 1137
|
1256tree 1257reverse_path (path) 1258 tree path; 1259{
| 1138tree 1139reverse_path (path) 1140 tree path; 1141{
|
1260 register tree prev = 0, tmp, next; 1261 for (tmp = path; tmp; tmp = next)
| 1142 register tree prev = NULL_TREE, cur; 1143 push_expression_obstack (); 1144 for (cur = path; cur; cur = BINFO_INHERITANCE_CHAIN (cur))
|
1262 {
| 1145 {
|
1263 next = BINFO_INHERITANCE_CHAIN (tmp); 1264 BINFO_INHERITANCE_CHAIN (tmp) = prev; 1265 prev = tmp;
| 1146 tree r = copy_node (cur); 1147 BINFO_INHERITANCE_CHAIN (r) = prev; 1148 prev = r;
|
1266 }
| 1149 }
|
| 1150 pop_obstacks ();
|
1267 return prev; 1268} 1269 1270void 1271debug_binfo (elem) 1272 tree elem; 1273{ 1274 unsigned HOST_WIDE_INT n; 1275 tree virtuals; 1276 1277 fprintf (stderr, "type \"%s\"; offset = %ld\n", 1278 TYPE_NAME_STRING (BINFO_TYPE (elem)), 1279 (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem))); 1280 fprintf (stderr, "vtable type:\n"); 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
| 1151 return prev; 1152} 1153 1154void 1155debug_binfo (elem) 1156 tree elem; 1157{ 1158 unsigned HOST_WIDE_INT n; 1159 tree virtuals; 1160 1161 fprintf (stderr, "type \"%s\"; offset = %ld\n", 1162 TYPE_NAME_STRING (BINFO_TYPE (elem)), 1163 (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem))); 1164 fprintf (stderr, "vtable type:\n"); 1165 debug_tree (BINFO_TYPE (elem)); 1166 if (BINFO_VTABLE (elem)) 1167 fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem)))); 1168 else 1169 fprintf (stderr, "no vtable decl yet\n"); 1170 fprintf (stderr, "virtuals:\n"); 1171 virtuals = BINFO_VIRTUALS (elem); 1172
|
1289 n = skip_rtti_stuff (&virtuals);
| 1173 n = skip_rtti_stuff (&virtuals, BINFO_TYPE (elem));
|
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; 1298 virtuals = TREE_CHAIN (virtuals); 1299 } 1300} 1301 1302/* Initialize an CPLUS_BINDING node that does not live on an obstack. */ 1303 1304tree 1305binding_init (node) 1306 struct tree_binding* node; 1307{ 1308 static struct tree_binding* source; 1309 if (!source) 1310 { 1311 extern struct obstack permanent_obstack; 1312 push_obstacks (&permanent_obstack, &permanent_obstack); 1313 source = (struct tree_binding*)make_node (CPLUS_BINDING); 1314 pop_obstacks (); 1315 } 1316 *node = *source; 1317 TREE_PERMANENT ((tree)node) = 0; 1318 return (tree)node; 1319} 1320 1321int 1322count_functions (t) 1323 tree t; 1324{ 1325 int i; 1326 if (TREE_CODE (t) == FUNCTION_DECL) 1327 return 1; 1328 else if (TREE_CODE (t) == OVERLOAD) 1329 { 1330 for (i=0; t; t = OVL_CHAIN (t)) 1331 i++; 1332 return i; 1333 } 1334 1335 my_friendly_abort (359); 1336 return 0; 1337} 1338 1339int 1340is_overloaded_fn (x) 1341 tree x; 1342{
| 1174 1175 while (virtuals) 1176 { 1177 tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0); 1178 fprintf (stderr, "%s [%ld =? %ld]\n", 1179 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)), 1180 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl))); 1181 ++n; 1182 virtuals = TREE_CHAIN (virtuals); 1183 } 1184} 1185 1186/* Initialize an CPLUS_BINDING node that does not live on an obstack. */ 1187 1188tree 1189binding_init (node) 1190 struct tree_binding* node; 1191{ 1192 static struct tree_binding* source; 1193 if (!source) 1194 { 1195 extern struct obstack permanent_obstack; 1196 push_obstacks (&permanent_obstack, &permanent_obstack); 1197 source = (struct tree_binding*)make_node (CPLUS_BINDING); 1198 pop_obstacks (); 1199 } 1200 *node = *source; 1201 TREE_PERMANENT ((tree)node) = 0; 1202 return (tree)node; 1203} 1204 1205int 1206count_functions (t) 1207 tree t; 1208{ 1209 int i; 1210 if (TREE_CODE (t) == FUNCTION_DECL) 1211 return 1; 1212 else if (TREE_CODE (t) == OVERLOAD) 1213 { 1214 for (i=0; t; t = OVL_CHAIN (t)) 1215 i++; 1216 return i; 1217 } 1218 1219 my_friendly_abort (359); 1220 return 0; 1221} 1222 1223int 1224is_overloaded_fn (x) 1225 tree x; 1226{
|
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 }
| 1227 /* A baselink is also considered an overloaded function. */ 1228 if (TREE_CODE (x) == OFFSET_REF) 1229 x = TREE_OPERAND (x, 1); 1230 if (BASELINK_P (x)) 1231 x = TREE_VALUE (x);
|
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{
| 1232 return (TREE_CODE (x) == FUNCTION_DECL 1233 || TREE_CODE (x) == TEMPLATE_ID_EXPR 1234 || DECL_FUNCTION_TEMPLATE_P (x) 1235 || TREE_CODE (x) == OVERLOAD); 1236} 1237 1238int 1239really_overloaded_fn (x) 1240 tree x; 1241{
|
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)
| 1242 /* A baselink is also considered an overloaded function. */ 1243 if (TREE_CODE (x) == OFFSET_REF) 1244 x = TREE_OPERAND (x, 1); 1245 if (BASELINK_P (x))
|
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. */
| 1246 x = TREE_VALUE (x); 1247 return (TREE_CODE (x) == OVERLOAD 1248 && (TREE_CHAIN (x) != NULL_TREE 1249 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x)))); 1250} 1251 1252tree 1253get_first_fn (from) 1254 tree from; 1255{ 1256 my_friendly_assert (is_overloaded_fn (from), 9); 1257 /* A baselink is also considered an overloaded function. */
|
1377 if (TREE_CODE (from) == TREE_LIST)
| 1258 if (BASELINK_P (from))
|
1378 from = TREE_VALUE (from); 1379 return OVL_CURRENT (from); 1380} 1381
| 1259 from = TREE_VALUE (from); 1260 return OVL_CURRENT (from); 1261} 1262
|
| 1263/* Returns nonzero if T is a ->* or .* expression that refers to a 1264 member function. */ 1265 1266int 1267bound_pmf_p (t) 1268 tree t; 1269{ 1270 return (TREE_CODE (t) == OFFSET_REF 1271 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1)))); 1272} 1273
|
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); 1390 TREE_TYPE (result) = unknown_type_node; 1391 OVL_FUNCTION (result) = decl; 1392 TREE_CHAIN (result) = chain; 1393 1394 return result; 1395} 1396 1397/* Same as ovl_cons, but on the scratch_obstack. */ 1398 1399tree 1400scratch_ovl_cons (value, chain) 1401 tree value, chain; 1402{ 1403 register tree node; 1404 register struct obstack *ambient_obstack = current_obstack; 1405 extern struct obstack *expression_obstack; 1406 current_obstack = expression_obstack; 1407 node = ovl_cons (value, chain); 1408 current_obstack = ambient_obstack; 1409 return node; 1410} 1411 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{
| 1274/* Return a new OVL node, concatenating it with the old one. */ 1275 1276tree 1277ovl_cons (decl, chain) 1278 tree decl; 1279 tree chain; 1280{ 1281 tree result = make_node (OVERLOAD); 1282 TREE_TYPE (result) = unknown_type_node; 1283 OVL_FUNCTION (result) = decl; 1284 TREE_CHAIN (result) = chain; 1285 1286 return result; 1287} 1288 1289/* Same as ovl_cons, but on the scratch_obstack. */ 1290 1291tree 1292scratch_ovl_cons (value, chain) 1293 tree value, chain; 1294{ 1295 register tree node; 1296 register struct obstack *ambient_obstack = current_obstack; 1297 extern struct obstack *expression_obstack; 1298 current_obstack = expression_obstack; 1299 node = ovl_cons (value, chain); 1300 current_obstack = ambient_obstack; 1301 return node; 1302} 1303 1304/* Build a new overloaded function. If this is the first one, 1305 just return it; otherwise, ovl_cons the _DECLs */ 1306 1307tree 1308build_overload (decl, chain) 1309 tree decl; 1310 tree chain; 1311{
|
1420 if (!chain)
| 1312 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
|
1421 return decl;
| 1313 return decl;
|
1422 if (TREE_CODE (chain) != OVERLOAD)
| 1314 if (chain && 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 1431static int 1432equal_functions (fn1, fn2) 1433 tree fn1; 1434 tree fn2; 1435{ 1436 if (!TREE_PERMANENT (fn1) || !TREE_PERMANENT (fn2)) 1437 return decls_match (fn1, fn2); 1438 return fn1 == fn2; 1439} 1440 1441/* True if fn is in ovl. */ 1442 1443int 1444ovl_member (fn, ovl) 1445 tree fn; 1446 tree ovl; 1447{ 1448 if (ovl == NULL_TREE) 1449 return 0; 1450 if (TREE_CODE (ovl) != OVERLOAD) 1451 return equal_functions (ovl, fn); 1452 for (; ovl; ovl = OVL_CHAIN (ovl)) 1453 if (equal_functions (OVL_FUNCTION (ovl), fn)) 1454 return 1; 1455 return 0; 1456} 1457 1458int 1459is_aggr_type_2 (t1, t2) 1460 tree t1, t2; 1461{ 1462 if (TREE_CODE (t1) != TREE_CODE (t2)) 1463 return 0; 1464 return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2); 1465} 1466 1467#define PRINT_RING_SIZE 4 1468 1469char * 1470lang_printable_name (decl, v) 1471 tree decl; 1472 int v; 1473{ 1474 static tree decl_ring[PRINT_RING_SIZE]; 1475 static char *print_ring[PRINT_RING_SIZE]; 1476 static int ring_counter; 1477 int i; 1478 1479 /* Only cache functions. */ 1480 if (v < 2 1481 || TREE_CODE (decl) != FUNCTION_DECL 1482 || DECL_LANG_SPECIFIC (decl) == 0) 1483 return lang_decl_name (decl, v); 1484 1485 /* See if this print name is lying around. */ 1486 for (i = 0; i < PRINT_RING_SIZE; i++) 1487 if (decl_ring[i] == decl) 1488 /* yes, so return it. */ 1489 return print_ring[i]; 1490 1491 if (++ring_counter == PRINT_RING_SIZE) 1492 ring_counter = 0; 1493 1494 if (current_function_decl != NULL_TREE) 1495 { 1496 if (decl_ring[ring_counter] == current_function_decl) 1497 ring_counter += 1; 1498 if (ring_counter == PRINT_RING_SIZE) 1499 ring_counter = 0; 1500 if (decl_ring[ring_counter] == current_function_decl) 1501 my_friendly_abort (106); 1502 } 1503 1504 if (print_ring[ring_counter]) 1505 free (print_ring[ring_counter]); 1506 1507 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v)); 1508 decl_ring[ring_counter] = decl; 1509 return print_ring[ring_counter]; 1510} 1511 1512/* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions 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);
| 1315 chain = ovl_cons (chain, NULL_TREE); 1316 return ovl_cons (decl, chain); 1317} 1318 1319/* Returns true iff functions are equivalent. Equivalent functions are 1320 not identical only if one is a function-local extern function. 1321 This assumes that function-locals don't have TREE_PERMANENT. */ 1322 1323static int 1324equal_functions (fn1, fn2) 1325 tree fn1; 1326 tree fn2; 1327{ 1328 if (!TREE_PERMANENT (fn1) || !TREE_PERMANENT (fn2)) 1329 return decls_match (fn1, fn2); 1330 return fn1 == fn2; 1331} 1332 1333/* True if fn is in ovl. */ 1334 1335int 1336ovl_member (fn, ovl) 1337 tree fn; 1338 tree ovl; 1339{ 1340 if (ovl == NULL_TREE) 1341 return 0; 1342 if (TREE_CODE (ovl) != OVERLOAD) 1343 return equal_functions (ovl, fn); 1344 for (; ovl; ovl = OVL_CHAIN (ovl)) 1345 if (equal_functions (OVL_FUNCTION (ovl), fn)) 1346 return 1; 1347 return 0; 1348} 1349 1350int 1351is_aggr_type_2 (t1, t2) 1352 tree t1, t2; 1353{ 1354 if (TREE_CODE (t1) != TREE_CODE (t2)) 1355 return 0; 1356 return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2); 1357} 1358 1359#define PRINT_RING_SIZE 4 1360 1361char * 1362lang_printable_name (decl, v) 1363 tree decl; 1364 int v; 1365{ 1366 static tree decl_ring[PRINT_RING_SIZE]; 1367 static char *print_ring[PRINT_RING_SIZE]; 1368 static int ring_counter; 1369 int i; 1370 1371 /* Only cache functions. */ 1372 if (v < 2 1373 || TREE_CODE (decl) != FUNCTION_DECL 1374 || DECL_LANG_SPECIFIC (decl) == 0) 1375 return lang_decl_name (decl, v); 1376 1377 /* See if this print name is lying around. */ 1378 for (i = 0; i < PRINT_RING_SIZE; i++) 1379 if (decl_ring[i] == decl) 1380 /* yes, so return it. */ 1381 return print_ring[i]; 1382 1383 if (++ring_counter == PRINT_RING_SIZE) 1384 ring_counter = 0; 1385 1386 if (current_function_decl != NULL_TREE) 1387 { 1388 if (decl_ring[ring_counter] == current_function_decl) 1389 ring_counter += 1; 1390 if (ring_counter == PRINT_RING_SIZE) 1391 ring_counter = 0; 1392 if (decl_ring[ring_counter] == current_function_decl) 1393 my_friendly_abort (106); 1394 } 1395 1396 if (print_ring[ring_counter]) 1397 free (print_ring[ring_counter]); 1398 1399 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v)); 1400 decl_ring[ring_counter] = decl; 1401 return print_ring[ring_counter]; 1402} 1403 1404/* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions 1405 listed in RAISES. */ 1406 1407tree 1408build_exception_variant (type, raises) 1409 tree type; 1410 tree raises; 1411{ 1412 tree v = TYPE_MAIN_VARIANT (type);
|
1521 int constp = TYPE_READONLY (type); 1522 int volatilep = TYPE_VOLATILE (type);
| 1413 int type_quals = TYPE_QUALS (type);
|
1523 1524 for (; v; v = TYPE_NEXT_VARIANT (v)) 1525 {
| 1414 1415 for (; v; v = TYPE_NEXT_VARIANT (v)) 1416 {
|
1526 if (TYPE_READONLY (v) != constp 1527 || TYPE_VOLATILE (v) != volatilep)
| 1417 tree t; 1418 tree u; 1419 1420 if (TYPE_QUALS (v) != type_quals)
|
1528 continue; 1529
| 1421 continue; 1422
|
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.
| 1423 for (t = TYPE_RAISES_EXCEPTIONS (v), u = raises; 1424 t != NULL_TREE && u != NULL_TREE; 1425 t = TREE_CHAIN (t), u = TREE_CHAIN (u)) 1426 if (((TREE_VALUE (t) != NULL_TREE) 1427 != (TREE_VALUE (u) != NULL_TREE)) 1428 || !same_type_p (TREE_VALUE (t), TREE_VALUE (u))) 1429 break;
|
1533
| 1430
|
1534 @@ Nice to free up storage used in consing up the 1535 @@ list of exceptions raised. */
| 1431 if (!t && !u) 1432 /* There's a memory leak here; RAISES is not freed. */
|
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))
| 1433 return v; 1434 } 1435 1436 /* Need to build a new variant. */ 1437 v = build_type_copy (type); 1438 1439 if (raises && ! TREE_PERMANENT (raises))
|
1543 { 1544 push_obstacks_nochange (); 1545 end_temporary_allocation (); 1546 raises = copy_list (raises); 1547 pop_obstacks (); 1548 }
| 1440 raises = copy_to_permanent (raises);
|
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);
| 1441 1442 TYPE_RAISES_EXCEPTIONS (v) = raises; 1443 return v; 1444} 1445 1446/* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its 1447 lang_specific field and its corresponding TEMPLATE_DECL node */ 1448 1449tree 1450copy_template_template_parm (t) 1451 tree t; 1452{ 1453 tree template = TYPE_NAME (t);
|
1562 tree t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
| 1454 tree t2; 1455 1456 /* Make sure these end up on the permanent_obstack. */ 1457 push_obstacks_nochange (); 1458 end_temporary_allocation (); 1459 1460 t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
|
1563 template = copy_node (template); 1564 copy_lang_decl (template);
| 1461 template = copy_node (template); 1462 copy_lang_decl (template);
|
| 1463 1464 pop_obstacks (); 1465
|
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);
| 1466 TREE_TYPE (template) = t2; 1467 TYPE_NAME (t2) = template; 1468 TYPE_STUB_DECL (t2) = template; 1469 1470 /* No need to copy these */ 1471 TYPE_FIELDS (t2) = TYPE_FIELDS (t);
|
1571 CLASSTYPE_TEMPLATE_INFO (t2) = CLASSTYPE_TEMPLATE_INFO (t);
| 1472 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2) 1473 = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
|
1572 return t2; 1573} 1574
| 1474 return t2; 1475} 1476
|
1575/* Subroutine of copy_to_permanent
| 1477/* Walk through the tree structure T, applying func. If func ever returns 1478 non-null, return that value. */
|
1576
| 1479
|
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
| 1480tree
|
1581mapcar (t, func)
| 1481search_tree (t, func)
|
1582 tree t; 1583 tree (*func) PROTO((tree)); 1584{
| 1482 tree t; 1483 tree (*func) PROTO((tree)); 1484{
|
| 1485#define TRY(ARG) if (tmp=search_tree (ARG, func), tmp != NULL_TREE) return tmp 1486
|
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:
| 1487 tree tmp; 1488 1489 if (t == NULL_TREE) 1490 return t; 1491 1492 if (tmp = func (t), tmp != NULL_TREE) 1493 return tmp; 1494 1495 switch (TREE_CODE (t)) 1496 { 1497 case ERROR_MARK:
|
| 1498 break; 1499 1500 case IDENTIFIER_NODE: 1501 break; 1502 1503 case VAR_DECL: 1504 case FUNCTION_DECL: 1505 case CONST_DECL: 1506 case TEMPLATE_DECL: 1507 case NAMESPACE_DECL: 1508 break; 1509 1510 case TYPE_DECL: 1511 TRY (TREE_TYPE (t)); 1512 break; 1513 1514 case PARM_DECL: 1515 TRY (TREE_TYPE (t)); 1516 TRY (TREE_CHAIN (t)); 1517 break; 1518 1519 case TREE_LIST: 1520 TRY (TREE_PURPOSE (t)); 1521 TRY (TREE_VALUE (t)); 1522 TRY (TREE_CHAIN (t)); 1523 break; 1524 1525 case OVERLOAD: 1526 TRY (OVL_FUNCTION (t)); 1527 TRY (OVL_CHAIN (t)); 1528 break; 1529 1530 case TREE_VEC: 1531 { 1532 int len = TREE_VEC_LENGTH (t); 1533 1534 t = copy_node (t); 1535 while (len--) 1536 TRY (TREE_VEC_ELT (t, len)); 1537 } 1538 break; 1539 1540 case INTEGER_CST: 1541 case REAL_CST: 1542 case STRING_CST: 1543 case DEFAULT_ARG: 1544 break; 1545 1546 case PTRMEM_CST: 1547 TRY (TREE_TYPE (t)); 1548 break; 1549 1550 case COND_EXPR: 1551 case TARGET_EXPR: 1552 case AGGR_INIT_EXPR: 1553 case NEW_EXPR: 1554 TRY (TREE_OPERAND (t, 0)); 1555 TRY (TREE_OPERAND (t, 1)); 1556 TRY (TREE_OPERAND (t, 2)); 1557 break; 1558 1559 case MODIFY_EXPR: 1560 case PLUS_EXPR: 1561 case MINUS_EXPR: 1562 case MULT_EXPR: 1563 case TRUNC_DIV_EXPR: 1564 case TRUNC_MOD_EXPR: 1565 case MIN_EXPR: 1566 case MAX_EXPR: 1567 case LSHIFT_EXPR: 1568 case RSHIFT_EXPR: 1569 case BIT_IOR_EXPR: 1570 case BIT_XOR_EXPR: 1571 case BIT_AND_EXPR: 1572 case BIT_ANDTC_EXPR: 1573 case TRUTH_ANDIF_EXPR: 1574 case TRUTH_ORIF_EXPR: 1575 case LT_EXPR: 1576 case LE_EXPR: 1577 case GT_EXPR: 1578 case GE_EXPR: 1579 case EQ_EXPR: 1580 case NE_EXPR: 1581 case CEIL_DIV_EXPR: 1582 case FLOOR_DIV_EXPR: 1583 case ROUND_DIV_EXPR: 1584 case CEIL_MOD_EXPR: 1585 case FLOOR_MOD_EXPR: 1586 case ROUND_MOD_EXPR: 1587 case COMPOUND_EXPR: 1588 case PREDECREMENT_EXPR: 1589 case PREINCREMENT_EXPR: 1590 case POSTDECREMENT_EXPR: 1591 case POSTINCREMENT_EXPR: 1592 case ARRAY_REF: 1593 case SCOPE_REF: 1594 case TRY_CATCH_EXPR: 1595 case WITH_CLEANUP_EXPR: 1596 case CALL_EXPR: 1597 TRY (TREE_OPERAND (t, 0)); 1598 TRY (TREE_OPERAND (t, 1)); 1599 break; 1600 1601 case SAVE_EXPR: 1602 case CONVERT_EXPR: 1603 case ADDR_EXPR: 1604 case INDIRECT_REF: 1605 case NEGATE_EXPR: 1606 case BIT_NOT_EXPR: 1607 case TRUTH_NOT_EXPR: 1608 case NOP_EXPR: 1609 case NON_LVALUE_EXPR: 1610 case COMPONENT_REF: 1611 case CLEANUP_POINT_EXPR: 1612 case LOOKUP_EXPR: 1613 case SIZEOF_EXPR: 1614 case ALIGNOF_EXPR: 1615 TRY (TREE_OPERAND (t, 0)); 1616 break; 1617 1618 case MODOP_EXPR: 1619 case CAST_EXPR: 1620 case REINTERPRET_CAST_EXPR: 1621 case CONST_CAST_EXPR: 1622 case STATIC_CAST_EXPR: 1623 case DYNAMIC_CAST_EXPR: 1624 case ARROW_EXPR: 1625 case DOTSTAR_EXPR: 1626 case TYPEID_EXPR: 1627 break; 1628 1629 case COMPLEX_CST: 1630 TRY (TREE_REALPART (t)); 1631 TRY (TREE_IMAGPART (t)); 1632 break; 1633 1634 case CONSTRUCTOR: 1635 TRY (CONSTRUCTOR_ELTS (t)); 1636 break; 1637 1638 case TEMPLATE_TEMPLATE_PARM: 1639 case TEMPLATE_PARM_INDEX: 1640 case TEMPLATE_TYPE_PARM: 1641 break; 1642 1643 case BIND_EXPR: 1644 break; 1645 1646 case REAL_TYPE: 1647 case COMPLEX_TYPE: 1648 case VOID_TYPE: 1649 case BOOLEAN_TYPE: 1650 case TYPENAME_TYPE: 1651 case UNION_TYPE: 1652 case ENUMERAL_TYPE: 1653 case TYPEOF_TYPE: 1654 break; 1655 1656 case POINTER_TYPE: 1657 case REFERENCE_TYPE: 1658 TRY (TREE_TYPE (t)); 1659 break; 1660 1661 case FUNCTION_TYPE: 1662 case METHOD_TYPE: 1663 TRY (TREE_TYPE (t)); 1664 TRY (TYPE_ARG_TYPES (t)); 1665 break; 1666 1667 case ARRAY_TYPE: 1668 TRY (TREE_TYPE (t)); 1669 TRY (TYPE_DOMAIN (t)); 1670 break; 1671 1672 case INTEGER_TYPE: 1673 TRY (TYPE_MAX_VALUE (t)); 1674 break; 1675 1676 case OFFSET_TYPE: 1677 TRY (TREE_TYPE (t)); 1678 TRY (TYPE_OFFSET_BASETYPE (t)); 1679 break; 1680 1681 case RECORD_TYPE: 1682 if (TYPE_PTRMEMFUNC_P (t)) 1683 TRY (TYPE_PTRMEMFUNC_FN_TYPE (t)); 1684 break; 1685 1686 /* This list is incomplete, but should suffice for now. 1687 It is very important that `sorry' not call 1688 `report_error_function'. That could cause an infinite loop. */ 1689 default: 1690 sorry ("initializer contains unrecognized tree code");
|
1596 return error_mark_node; 1597
| 1691 return error_mark_node; 1692
|
| 1693 } 1694 1695 return NULL_TREE; 1696 1697#undef TRY 1698} 1699 1700/* Passed to search_tree. Checks for the use of types with no linkage. */ 1701 1702static tree 1703no_linkage_helper (t) 1704 tree t; 1705{ 1706 if (TYPE_P (t) 1707 && (IS_AGGR_TYPE (t) || TREE_CODE (t) == ENUMERAL_TYPE) 1708 && (decl_function_context (TYPE_MAIN_DECL (t)) 1709 || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))) 1710 return t; 1711 return NULL_TREE; 1712} 1713 1714/* Check if the type T depends on a type with no linkage and if so, return 1715 it. */ 1716 1717tree 1718no_linkage_check (t) 1719 tree t; 1720{ 1721 t = search_tree (t, no_linkage_helper); 1722 if (t != error_mark_node) 1723 return t; 1724 return NULL_TREE; 1725} 1726 1727 1728/* Make copies of all the nodes below T. If FUNC is non-NULL, call it 1729 for each node. */ 1730 1731tree 1732mapcar (t, func) 1733 tree t; 1734 tree (*func) PROTO((tree)); 1735{ 1736 tree tmp; 1737 1738 if (t == NULL_TREE) 1739 return t; 1740 1741 if (func) 1742 { 1743 tmp = func (t); 1744 if (tmp) 1745 return tmp; 1746 } 1747 1748 switch (TREE_CODE (t)) 1749 { 1750 case ERROR_MARK: 1751 return error_mark_node; 1752
|
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. */
| 1753 case VAR_DECL: 1754 case FUNCTION_DECL: 1755 case CONST_DECL: 1756 /* Rather than aborting, return error_mark_node. This allows us 1757 to report a sensible error message on code like this: 1758 1759 void g() { int i; f<i>(7); } 1760 1761 In a case like: 1762 1763 void g() { const int i = 7; f<i>(7); } 1764 1765 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;
| 1766 if (TREE_READONLY_DECL_P (t)) 1767 { 1768 tmp = decl_constant_value (t); 1769 if (tmp != t) 1770 return mapcar (tmp, func); 1771 } 1772 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); 1624 DECL_SIZE (t) = mapcar (DECL_SIZE (t), func); 1625 return t; 1626 } 1627 1628 case TREE_LIST: 1629 { 1630 tree chain = TREE_CHAIN (t); 1631 t = copy_node (t); 1632 TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func); 1633 TREE_VALUE (t) = mapcar (TREE_VALUE (t), func); 1634 TREE_CHAIN (t) = mapcar (chain, func); 1635 return t; 1636 } 1637 1638 case OVERLOAD: 1639 { 1640 tree chain = OVL_CHAIN (t); 1641 t = copy_node (t); 1642 OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func); 1643 OVL_CHAIN (t) = mapcar (chain, func); 1644 return t; 1645 } 1646 1647 case TREE_VEC: 1648 { 1649 int len = TREE_VEC_LENGTH (t); 1650 1651 t = copy_node (t); 1652 while (len--) 1653 TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func); 1654 return t; 1655 } 1656 1657 case INTEGER_CST: 1658 case REAL_CST: 1659 case STRING_CST: 1660 return copy_node (t); 1661
| 1773 1774 case PARM_DECL: 1775 { 1776 tree chain = TREE_CHAIN (t); 1777 t = copy_node (t); 1778 TREE_CHAIN (t) = mapcar (chain, func); 1779 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func); 1780 DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func); 1781 DECL_SIZE (t) = mapcar (DECL_SIZE (t), func); 1782 return t; 1783 } 1784 1785 case TREE_LIST: 1786 { 1787 tree chain = TREE_CHAIN (t); 1788 t = copy_node (t); 1789 TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func); 1790 TREE_VALUE (t) = mapcar (TREE_VALUE (t), func); 1791 TREE_CHAIN (t) = mapcar (chain, func); 1792 return t; 1793 } 1794 1795 case OVERLOAD: 1796 { 1797 tree chain = OVL_CHAIN (t); 1798 t = copy_node (t); 1799 OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func); 1800 OVL_CHAIN (t) = mapcar (chain, func); 1801 return t; 1802 } 1803 1804 case TREE_VEC: 1805 { 1806 int len = TREE_VEC_LENGTH (t); 1807 1808 t = copy_node (t); 1809 while (len--) 1810 TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func); 1811 return t; 1812 } 1813 1814 case INTEGER_CST: 1815 case REAL_CST: 1816 case STRING_CST: 1817 return copy_node (t); 1818
|
| 1819 case PTRMEM_CST: 1820 t = copy_node (t); 1821 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func); 1822 PTRMEM_CST_MEMBER (t) = mapcar (PTRMEM_CST_MEMBER (t), func); 1823 return t; 1824
|
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; 1670 1671 case SAVE_EXPR: 1672 t = copy_node (t); 1673 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1674 return t; 1675 1676 case MODIFY_EXPR: 1677 case PLUS_EXPR: 1678 case MINUS_EXPR: 1679 case MULT_EXPR: 1680 case TRUNC_DIV_EXPR: 1681 case TRUNC_MOD_EXPR: 1682 case MIN_EXPR: 1683 case MAX_EXPR: 1684 case LSHIFT_EXPR: 1685 case RSHIFT_EXPR: 1686 case BIT_IOR_EXPR: 1687 case BIT_XOR_EXPR: 1688 case BIT_AND_EXPR: 1689 case BIT_ANDTC_EXPR: 1690 case TRUTH_ANDIF_EXPR: 1691 case TRUTH_ORIF_EXPR: 1692 case LT_EXPR: 1693 case LE_EXPR: 1694 case GT_EXPR: 1695 case GE_EXPR: 1696 case EQ_EXPR: 1697 case NE_EXPR: 1698 case CEIL_DIV_EXPR: 1699 case FLOOR_DIV_EXPR: 1700 case ROUND_DIV_EXPR: 1701 case CEIL_MOD_EXPR: 1702 case FLOOR_MOD_EXPR: 1703 case ROUND_MOD_EXPR: 1704 case COMPOUND_EXPR: 1705 case PREDECREMENT_EXPR: 1706 case PREINCREMENT_EXPR: 1707 case POSTDECREMENT_EXPR: 1708 case POSTINCREMENT_EXPR: 1709 case ARRAY_REF: 1710 case SCOPE_REF: 1711 case TRY_CATCH_EXPR: 1712 case WITH_CLEANUP_EXPR: 1713 t = copy_node (t); 1714 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1715 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func); 1716 return t; 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
| 1825 case COND_EXPR: 1826 case TARGET_EXPR: 1827 case AGGR_INIT_EXPR: 1828 t = copy_node (t); 1829 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1830 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func); 1831 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func); 1832 return t; 1833 1834 case SAVE_EXPR: 1835 t = copy_node (t); 1836 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1837 return t; 1838 1839 case MODIFY_EXPR: 1840 case PLUS_EXPR: 1841 case MINUS_EXPR: 1842 case MULT_EXPR: 1843 case TRUNC_DIV_EXPR: 1844 case TRUNC_MOD_EXPR: 1845 case MIN_EXPR: 1846 case MAX_EXPR: 1847 case LSHIFT_EXPR: 1848 case RSHIFT_EXPR: 1849 case BIT_IOR_EXPR: 1850 case BIT_XOR_EXPR: 1851 case BIT_AND_EXPR: 1852 case BIT_ANDTC_EXPR: 1853 case TRUTH_ANDIF_EXPR: 1854 case TRUTH_ORIF_EXPR: 1855 case LT_EXPR: 1856 case LE_EXPR: 1857 case GT_EXPR: 1858 case GE_EXPR: 1859 case EQ_EXPR: 1860 case NE_EXPR: 1861 case CEIL_DIV_EXPR: 1862 case FLOOR_DIV_EXPR: 1863 case ROUND_DIV_EXPR: 1864 case CEIL_MOD_EXPR: 1865 case FLOOR_MOD_EXPR: 1866 case ROUND_MOD_EXPR: 1867 case COMPOUND_EXPR: 1868 case PREDECREMENT_EXPR: 1869 case PREINCREMENT_EXPR: 1870 case POSTDECREMENT_EXPR: 1871 case POSTINCREMENT_EXPR: 1872 case ARRAY_REF: 1873 case SCOPE_REF: 1874 case TRY_CATCH_EXPR: 1875 case WITH_CLEANUP_EXPR: 1876 t = copy_node (t); 1877 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1878 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func); 1879 return t; 1880 1881 case CALL_EXPR: 1882 t = copy_node (t); 1883 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func); 1884 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1885 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func); 1886 1887 /* tree.def says that operand two is RTL, but
|
1725 build_call_declarator puts trees in there. */
| 1888 make_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:
| 1889 if (TREE_OPERAND (t, 2) 1890 && TREE_CODE (TREE_OPERAND (t, 2)) == TREE_LIST) 1891 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func); 1892 else 1893 TREE_OPERAND (t, 2) = NULL_TREE; 1894 return t; 1895 1896 case CONVERT_EXPR: 1897 case ADDR_EXPR: 1898 case INDIRECT_REF: 1899 case NEGATE_EXPR: 1900 case BIT_NOT_EXPR: 1901 case TRUTH_NOT_EXPR: 1902 case NOP_EXPR: 1903 case COMPONENT_REF: 1904 case CLEANUP_POINT_EXPR:
|
| 1905 case NON_LVALUE_EXPR:
|
1742 t = copy_node (t);
| 1906 t = copy_node (t);
|
| 1907 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
|
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));
| 1908 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1909 return t; 1910 1911 case POINTER_TYPE: 1912 tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
|
1748 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
| 1913 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
|
1749 case REFERENCE_TYPE: 1750 tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
| 1914 case REFERENCE_TYPE: 1915 tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
|
1751 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
| 1916 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
|
1752 case FUNCTION_TYPE: 1753 tmp = build_function_type (mapcar (TREE_TYPE (t), func), 1754 mapcar (TYPE_ARG_TYPES (t), func));
| 1917 case FUNCTION_TYPE: 1918 tmp = build_function_type (mapcar (TREE_TYPE (t), func), 1919 mapcar (TYPE_ARG_TYPES (t), func));
|
1755 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
| 1920 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
|
1756 case ARRAY_TYPE: 1757 tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func), 1758 mapcar (TYPE_DOMAIN (t), func));
| 1921 case ARRAY_TYPE: 1922 tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func), 1923 mapcar (TYPE_DOMAIN (t), func));
|
1759 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
| 1924 return cp_build_qualified_type (tmp, CP_TYPE_QUALS (t));
|
1760 case INTEGER_TYPE: 1761 tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
| 1925 case INTEGER_TYPE: 1926 tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
|
1762 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
| 1927 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
|
1763 case OFFSET_TYPE: 1764 tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func), 1765 mapcar (TREE_TYPE (t), func));
| 1928 case OFFSET_TYPE: 1929 tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func), 1930 mapcar (TREE_TYPE (t), func));
|
1766 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
| 1931 return cp_build_qualified_type (tmp, TYPE_QUALS (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));
| 1932 case METHOD_TYPE: 1933 tmp = build_cplus_method_type 1934 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func), 1935 mapcar (TREE_TYPE (t), func), 1936 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
|
1772 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
| 1937 return cp_build_qualified_type (tmp, TYPE_QUALS (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: 1781 t = copy_node (t); 1782 CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func); 1783 return t; 1784 1785 case TEMPLATE_TEMPLATE_PARM: 1786 return copy_template_template_parm (t); 1787 1788 case BIND_EXPR: 1789 t = copy_node (t); 1790 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1791 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func); 1792 TREE_OPERAND (t, 2) = NULL_TREE; 1793 return t; 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
| 1938 1939 case COMPLEX_CST: 1940 t = copy_node (t); 1941 TREE_REALPART (t) = mapcar (TREE_REALPART (t), func); 1942 TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func); 1943 return t; 1944 1945 case CONSTRUCTOR: 1946 t = copy_node (t); 1947 CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func); 1948 return t; 1949 1950 case TEMPLATE_TEMPLATE_PARM: 1951 return copy_template_template_parm (t); 1952 1953 case BIND_EXPR: 1954 t = copy_node (t); 1955 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1956 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func); 1957 TREE_OPERAND (t, 2) = NULL_TREE; 1958 return t; 1959 1960 case NEW_EXPR: 1961 t = copy_node (t); 1962 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1963 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func); 1964 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func); 1965 return t; 1966
|
| 1967 case LOOKUP_EXPR: 1968 t = copy_node (t); 1969 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func); 1970 return t; 1971
|
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
| 1972 case RECORD_TYPE: 1973 if (TYPE_PTRMEMFUNC_P (t)) 1974 return build_ptrmemfunc_type 1975 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func)); 1976 /* else fall through */ 1977 1978 /* This list is incomplete, but should suffice for now. 1979 It is very important that `sorry' not call 1980 `report_error_function'. That could cause an infinite loop. */ 1981 default: 1982 sorry ("initializer contains unrecognized tree code"); 1983 return error_mark_node; 1984 1985 } 1986 my_friendly_abort (107); 1987 /* NOTREACHED */ 1988 return NULL_TREE; 1989} 1990
|
| 1991/* Returns T if T is allocated on the permanent obstack, NULL_TREE 1992 otherwise. */ 1993 1994tree 1995permanent_p (t) 1996 tree t; 1997{ 1998 return TREE_PERMANENT (t) ? t : NULL_TREE; 1999} 2000
|
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; }' */ 1829 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL) 1830 && TREE_PUBLIC (t)) 1831 { 1832 t = copy_node (t); 1833 1834 /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again. */ 1835 DECL_RTL (t) = 0; 1836 make_decl_rtl (t, NULL_PTR, 1); 1837 1838 return t; 1839 } 1840 return NULL_TREE; 1841} 1842 1843/* Assuming T is a node built bottom-up, make it all exist on 1844 permanent obstack, if it is not permanent already. */ 1845 1846tree 1847copy_to_permanent (t) 1848 tree t; 1849{ 1850 if (t == NULL_TREE || TREE_PERMANENT (t)) 1851 return t; 1852 1853 push_obstacks_nochange (); 1854 end_temporary_allocation (); 1855 1856 t = mapcar (t, perm_manip); 1857 1858 pop_obstacks (); 1859 1860 return t; 1861} 1862 1863#ifdef GATHER_STATISTICS 1864extern int depth_reached; 1865#endif 1866 1867void 1868print_lang_statistics () 1869{ 1870 extern struct obstack decl_obstack; 1871 print_obstack_statistics ("class_obstack", &class_obstack); 1872 print_obstack_statistics ("decl_obstack", &decl_obstack); 1873 print_search_statistics (); 1874 print_class_statistics (); 1875#ifdef GATHER_STATISTICS 1876 fprintf (stderr, "maximum template instantiation depth reached: %d\n", 1877 depth_reached); 1878#endif 1879} 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)
| 2001static tree 2002perm_manip (t) 2003 tree t; 2004{ 2005 if (TREE_PERMANENT (t)) 2006 return t; 2007 2008 /* Support `void f () { extern int i; A<&i> a; }' */ 2009 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL) 2010 && TREE_PUBLIC (t)) 2011 { 2012 t = copy_node (t); 2013 2014 /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again. */ 2015 DECL_RTL (t) = 0; 2016 make_decl_rtl (t, NULL_PTR, 1); 2017 2018 return t; 2019 } 2020 return NULL_TREE; 2021} 2022 2023/* Assuming T is a node built bottom-up, make it all exist on 2024 permanent obstack, if it is not permanent already. */ 2025 2026tree 2027copy_to_permanent (t) 2028 tree t; 2029{ 2030 if (t == NULL_TREE || TREE_PERMANENT (t)) 2031 return t; 2032 2033 push_obstacks_nochange (); 2034 end_temporary_allocation (); 2035 2036 t = mapcar (t, perm_manip); 2037 2038 pop_obstacks (); 2039 2040 return t; 2041} 2042 2043#ifdef GATHER_STATISTICS 2044extern int depth_reached; 2045#endif 2046 2047void 2048print_lang_statistics () 2049{ 2050 extern struct obstack decl_obstack; 2051 print_obstack_statistics ("class_obstack", &class_obstack); 2052 print_obstack_statistics ("decl_obstack", &decl_obstack); 2053 print_search_statistics (); 2054 print_class_statistics (); 2055#ifdef GATHER_STATISTICS 2056 fprintf (stderr, "maximum template instantiation depth reached: %d\n", 2057 depth_reached); 2058#endif 2059} 2060 2061/* This is used by the `assert' macro. It is provided in libgcc.a, 2062 which `cc' doesn't know how to link. Note that the C++ front-end 2063 no longer actually uses the `assert' macro (instead, it calls 2064 my_friendly_assert). But all of the back-end files still need this. */ 2065 2066void 2067__eprintf (string, expression, line, filename)
|
1888#ifdef __STDC__
| |
1889 const char *string; 1890 const char *expression; 1891 unsigned line; 1892 const char *filename;
| 2068 const char *string; 2069 const char *expression; 2070 unsigned line; 2071 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 1907 array. */ 1908 1909tree 1910array_type_nelts_top (type) 1911 tree type; 1912{ 1913 return fold (build (PLUS_EXPR, sizetype, 1914 array_type_nelts (type), 1915 integer_one_node)); 1916} 1917 1918/* Return, as an INTEGER_CST node, the number of elements for TYPE 1919 (which is an ARRAY_TYPE). This one is a recursive count of all 1920 ARRAY_TYPEs that are clumped together. */ 1921 1922tree 1923array_type_nelts_total (type) 1924 tree type; 1925{ 1926 tree sz = array_type_nelts_top (type); 1927 type = TREE_TYPE (type); 1928 while (TREE_CODE (type) == ARRAY_TYPE) 1929 { 1930 tree n = array_type_nelts_top (type); 1931 sz = fold (build (MULT_EXPR, sizetype, sz, n)); 1932 type = TREE_TYPE (type); 1933 } 1934 return sz; 1935} 1936 1937static 1938tree 1939bot_manip (t) 1940 tree t; 1941{ 1942 if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t)) 1943 return t; 1944 else if (TREE_CODE (t) == TARGET_EXPR) 1945 { 1946 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR) 1947 { 1948 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0)); 1949 return build_cplus_new 1950 (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1))); 1951 } 1952 t = copy_node (t); 1953 TREE_OPERAND (t, 0) = build (VAR_DECL, TREE_TYPE (t)); 1954 layout_decl (TREE_OPERAND (t, 0), 0); 1955 return t; 1956 } 1957 else if (TREE_CODE (t) == CALL_EXPR) 1958 mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0)); 1959 1960 return NULL_TREE; 1961} 1962 1963/* Actually, we'll just clean out the target exprs for the moment. */ 1964 1965tree 1966break_out_target_exprs (t) 1967 tree t; 1968{ 1969 return mapcar (t, bot_manip); 1970} 1971 1972/* Obstack used for allocating nodes in template function and variable 1973 definitions. */ 1974 1975/* Similar to `build_nt', except we build 1976 on the permanent_obstack, regardless. */ 1977 1978tree 1979build_min_nt VPROTO((enum tree_code code, ...)) 1980{ 1981#ifndef __STDC__ 1982 enum tree_code code; 1983#endif 1984 register struct obstack *ambient_obstack = expression_obstack; 1985 va_list p; 1986 register tree t; 1987 register int length; 1988 register int i; 1989 1990 VA_START (p, code); 1991 1992#ifndef __STDC__ 1993 code = va_arg (p, enum tree_code); 1994#endif 1995 1996 expression_obstack = &permanent_obstack; 1997 1998 t = make_node (code); 1999 length = tree_code_length[(int) code]; 2000 TREE_COMPLEXITY (t) = lineno; 2001 2002 for (i = 0; i < length; i++) 2003 { 2004 tree x = va_arg (p, tree); 2005 TREE_OPERAND (t, i) = copy_to_permanent (x); 2006 } 2007 2008 va_end (p); 2009 expression_obstack = ambient_obstack; 2010 return t; 2011} 2012 2013/* Similar to `build', except we build 2014 on the permanent_obstack, regardless. */ 2015 2016tree 2017build_min VPROTO((enum tree_code code, tree tt, ...)) 2018{ 2019#ifndef __STDC__ 2020 enum tree_code code; 2021 tree tt; 2022#endif 2023 register struct obstack *ambient_obstack = expression_obstack; 2024 va_list p; 2025 register tree t; 2026 register int length; 2027 register int i; 2028 2029 VA_START (p, tt); 2030 2031#ifndef __STDC__ 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];
| 2072{ 2073 fprintf (stderr, string, expression, line, filename); 2074 fflush (stderr); 2075 abort (); 2076} 2077 2078/* Return, as an INTEGER_CST node, the number of elements for TYPE 2079 (which is an ARRAY_TYPE). This counts only elements of the top 2080 array. */ 2081 2082tree 2083array_type_nelts_top (type) 2084 tree type; 2085{ 2086 return fold (build (PLUS_EXPR, sizetype, 2087 array_type_nelts (type), 2088 integer_one_node)); 2089} 2090 2091/* Return, as an INTEGER_CST node, the number of elements for TYPE 2092 (which is an ARRAY_TYPE). This one is a recursive count of all 2093 ARRAY_TYPEs that are clumped together. */ 2094 2095tree 2096array_type_nelts_total (type) 2097 tree type; 2098{ 2099 tree sz = array_type_nelts_top (type); 2100 type = TREE_TYPE (type); 2101 while (TREE_CODE (type) == ARRAY_TYPE) 2102 { 2103 tree n = array_type_nelts_top (type); 2104 sz = fold (build (MULT_EXPR, sizetype, sz, n)); 2105 type = TREE_TYPE (type); 2106 } 2107 return sz; 2108} 2109 2110static 2111tree 2112bot_manip (t) 2113 tree t; 2114{ 2115 if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t)) 2116 return t; 2117 else if (TREE_CODE (t) == TARGET_EXPR) 2118 { 2119 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR) 2120 { 2121 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0)); 2122 return build_cplus_new 2123 (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1))); 2124 } 2125 t = copy_node (t); 2126 TREE_OPERAND (t, 0) = build (VAR_DECL, TREE_TYPE (t)); 2127 layout_decl (TREE_OPERAND (t, 0), 0); 2128 return t; 2129 } 2130 else if (TREE_CODE (t) == CALL_EXPR) 2131 mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0)); 2132 2133 return NULL_TREE; 2134} 2135 2136/* Actually, we'll just clean out the target exprs for the moment. */ 2137 2138tree 2139break_out_target_exprs (t) 2140 tree t; 2141{ 2142 return mapcar (t, bot_manip); 2143} 2144 2145/* Obstack used for allocating nodes in template function and variable 2146 definitions. */ 2147 2148/* Similar to `build_nt', except we build 2149 on the permanent_obstack, regardless. */ 2150 2151tree 2152build_min_nt VPROTO((enum tree_code code, ...)) 2153{ 2154#ifndef __STDC__ 2155 enum tree_code code; 2156#endif 2157 register struct obstack *ambient_obstack = expression_obstack; 2158 va_list p; 2159 register tree t; 2160 register int length; 2161 register int i; 2162 2163 VA_START (p, code); 2164 2165#ifndef __STDC__ 2166 code = va_arg (p, enum tree_code); 2167#endif 2168 2169 expression_obstack = &permanent_obstack; 2170 2171 t = make_node (code); 2172 length = tree_code_length[(int) code]; 2173 TREE_COMPLEXITY (t) = lineno; 2174 2175 for (i = 0; i < length; i++) 2176 { 2177 tree x = va_arg (p, tree); 2178 TREE_OPERAND (t, i) = copy_to_permanent (x); 2179 } 2180 2181 va_end (p); 2182 expression_obstack = ambient_obstack; 2183 return t; 2184} 2185 2186/* Similar to `build', except we build 2187 on the permanent_obstack, regardless. */ 2188 2189tree 2190build_min VPROTO((enum tree_code code, tree tt, ...)) 2191{ 2192#ifndef __STDC__ 2193 enum tree_code code; 2194 tree tt; 2195#endif 2196 register struct obstack *ambient_obstack = expression_obstack; 2197 va_list p; 2198 register tree t; 2199 register int length; 2200 register int i; 2201 2202 VA_START (p, tt); 2203 2204#ifndef __STDC__ 2205 code = va_arg (p, enum tree_code); 2206 tt = va_arg (p, tree); 2207#endif 2208 2209 expression_obstack = &permanent_obstack; 2210 2211 t = make_node (code); 2212 length = tree_code_length[(int) code];
|
2040 TREE_TYPE (t) = tt;
| 2213 TREE_TYPE (t) = copy_to_permanent (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 2049 va_end (p); 2050 expression_obstack = ambient_obstack; 2051 return t; 2052} 2053 2054/* Same as `tree_cons' but make a permanent object. */ 2055 2056tree 2057min_tree_cons (purpose, value, chain) 2058 tree purpose, value, chain; 2059{ 2060 register tree node; 2061 register struct obstack *ambient_obstack = current_obstack; 2062 current_obstack = &permanent_obstack; 2063 2064 node = tree_cons (copy_to_permanent (purpose), 2065 copy_to_permanent (value), chain); 2066 current_obstack = ambient_obstack; 2067 return node; 2068} 2069 2070tree 2071get_type_decl (t) 2072 tree t; 2073{ 2074 if (TREE_CODE (t) == TYPE_DECL) 2075 return t; 2076 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') 2077 return TYPE_STUB_DECL (t); 2078 2079 my_friendly_abort (42); 2080 2081 /* Stop compiler from complaining control reaches end of non-void function. */ 2082 return 0; 2083} 2084 2085int 2086can_free (obstack, t) 2087 struct obstack *obstack; 2088 tree t; 2089{ 2090 int size = 0; 2091 2092 if (TREE_CODE (t) == TREE_VEC) 2093 size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec); 2094 else 2095 my_friendly_abort (42); 2096 2097#define ROUND(x) ((x + obstack_alignment_mask (obstack)) \ 2098 & ~ obstack_alignment_mask (obstack)) 2099 if ((char *)t + ROUND (size) == obstack_next_free (obstack)) 2100 return 1; 2101#undef ROUND 2102 2103 return 0; 2104} 2105 2106/* Return first vector element whose BINFO_TYPE is ELEM. 2107 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */ 2108 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)
| 2214 TREE_COMPLEXITY (t) = lineno; 2215 2216 for (i = 0; i < length; i++) 2217 { 2218 tree x = va_arg (p, tree); 2219 TREE_OPERAND (t, i) = copy_to_permanent (x); 2220 } 2221 2222 va_end (p); 2223 expression_obstack = ambient_obstack; 2224 return t; 2225} 2226 2227/* Same as `tree_cons' but make a permanent object. */ 2228 2229tree 2230min_tree_cons (purpose, value, chain) 2231 tree purpose, value, chain; 2232{ 2233 register tree node; 2234 register struct obstack *ambient_obstack = current_obstack; 2235 current_obstack = &permanent_obstack; 2236 2237 node = tree_cons (copy_to_permanent (purpose), 2238 copy_to_permanent (value), chain); 2239 current_obstack = ambient_obstack; 2240 return node; 2241} 2242 2243tree 2244get_type_decl (t) 2245 tree t; 2246{ 2247 if (TREE_CODE (t) == TYPE_DECL) 2248 return t; 2249 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') 2250 return TYPE_STUB_DECL (t); 2251 2252 my_friendly_abort (42); 2253 2254 /* Stop compiler from complaining control reaches end of non-void function. */ 2255 return 0; 2256} 2257 2258int 2259can_free (obstack, t) 2260 struct obstack *obstack; 2261 tree t; 2262{ 2263 int size = 0; 2264 2265 if (TREE_CODE (t) == TREE_VEC) 2266 size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec); 2267 else 2268 my_friendly_abort (42); 2269 2270#define ROUND(x) ((x + obstack_alignment_mask (obstack)) \ 2271 & ~ obstack_alignment_mask (obstack)) 2272 if ((char *)t + ROUND (size) == obstack_next_free (obstack)) 2273 return 1; 2274#undef ROUND 2275 2276 return 0; 2277} 2278 2279/* Return first vector element whose BINFO_TYPE is ELEM. 2280 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */ 2281 2282tree 2283vec_binfo_member (elem, vec) 2284 tree elem, vec; 2285{ 2286 int i; 2287 2288 if (vec) 2289 for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
|
2117 if (comptypes (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i)), 1))
| 2290 if (same_type_p (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i))))
|
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
| 2291 return TREE_VEC_ELT (vec, i); 2292 2293 return NULL_TREE; 2294} 2295 2296/* Kludge around the fact that DECL_CONTEXT for virtual functions returns 2297 the wrong thing for decl_function_context. Hopefully the uses in the 2298 backend won't matter, since we don't need a static chain for local class 2299 methods. FIXME! */ 2300 2301tree 2302hack_decl_function_context (decl) 2303 tree decl; 2304{ 2305 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl)) 2306 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl))); 2307 return decl_function_context (decl); 2308} 2309
|
| 2310/* Returns the namespace that contains DECL, whether directly or 2311 indirectly. */ 2312 2313tree 2314decl_namespace_context (decl) 2315 tree decl; 2316{ 2317 while (1) 2318 { 2319 if (TREE_CODE (decl) == NAMESPACE_DECL) 2320 return decl; 2321 else if (TYPE_P (decl)) 2322 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl)); 2323 else 2324 decl = CP_DECL_CONTEXT (decl); 2325 } 2326} 2327
|
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) 2145 tree t1, t2; 2146{ 2147 register enum tree_code code1, code2; 2148 int cmp; 2149 2150 if (t1 == t2) 2151 return 1; 2152 if (t1 == 0 || t2 == 0) 2153 return 0; 2154 2155 code1 = TREE_CODE (t1); 2156 code2 = TREE_CODE (t2); 2157 2158 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR) 2159 { 2160 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR) 2161 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2162 else 2163 return cp_tree_equal (TREE_OPERAND (t1, 0), t2); 2164 } 2165 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR 2166 || code2 == NON_LVALUE_EXPR) 2167 return cp_tree_equal (t1, TREE_OPERAND (t2, 0)); 2168 2169 if (code1 != code2) 2170 return 0; 2171 2172 switch (code1) 2173 { 2174 case INTEGER_CST: 2175 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) 2176 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2); 2177 2178 case REAL_CST: 2179 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); 2180 2181 case STRING_CST: 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. */
| 2328/* Return truthvalue of whether T1 is the same tree structure as T2. 2329 Return 1 if they are the same. 2330 Return 0 if they are understandably different. 2331 Return -1 if either contains tree structure not understood by 2332 this function. */ 2333 2334int 2335cp_tree_equal (t1, t2) 2336 tree t1, t2; 2337{ 2338 register enum tree_code code1, code2; 2339 int cmp; 2340 2341 if (t1 == t2) 2342 return 1; 2343 if (t1 == 0 || t2 == 0) 2344 return 0; 2345 2346 code1 = TREE_CODE (t1); 2347 code2 = TREE_CODE (t2); 2348 2349 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR) 2350 { 2351 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR) 2352 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2353 else 2354 return cp_tree_equal (TREE_OPERAND (t1, 0), t2); 2355 } 2356 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR 2357 || code2 == NON_LVALUE_EXPR) 2358 return cp_tree_equal (t1, TREE_OPERAND (t2, 0)); 2359 2360 if (code1 != code2) 2361 return 0; 2362 2363 switch (code1) 2364 { 2365 case INTEGER_CST: 2366 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) 2367 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2); 2368 2369 case REAL_CST: 2370 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); 2371 2372 case STRING_CST: 2373 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) 2374 && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), 2375 TREE_STRING_LENGTH (t1)); 2376 2377 case CONSTRUCTOR: 2378 /* We need to do this when determining whether or not two 2379 non-type pointer to member function template arguments 2380 are the same. */
|
2190 if (!(comptypes (TREE_TYPE (t1), TREE_TYPE (t2), 1)
| 2381 if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
|
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) 2199 return cmp; 2200 cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)); 2201 if (cmp <= 0) 2202 return cmp; 2203 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2)); 2204 2205 case SAVE_EXPR: 2206 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2207 2208 case CALL_EXPR: 2209 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2210 if (cmp <= 0) 2211 return cmp; 2212 return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 2213 2214 case TARGET_EXPR: 2215 /* Special case: if either target is an unallocated VAR_DECL, 2216 it means that it's going to be unified with whatever the 2217 TARGET_EXPR is really supposed to initialize, so treat it 2218 as being equivalent to anything. */ 2219 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL 2220 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE 2221 && DECL_RTL (TREE_OPERAND (t1, 0)) == 0) 2222 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL 2223 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE 2224 && DECL_RTL (TREE_OPERAND (t2, 0)) == 0)) 2225 cmp = 1; 2226 else 2227 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2228 if (cmp <= 0) 2229 return cmp; 2230 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 2231 2232 case WITH_CLEANUP_EXPR: 2233 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2234 if (cmp <= 0) 2235 return cmp; 2236 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2)); 2237 2238 case COMPONENT_REF: 2239 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1)) 2240 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2241 return 0; 2242 2243 case VAR_DECL: 2244 case PARM_DECL: 2245 case CONST_DECL: 2246 case FUNCTION_DECL: 2247 return 0; 2248 2249 case TEMPLATE_PARM_INDEX: 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')
| 2382 /* The first operand is RTL. */ 2383 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0))) 2384 return 0; 2385 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 2386 2387 case TREE_LIST: 2388 cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)); 2389 if (cmp <= 0) 2390 return cmp; 2391 cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)); 2392 if (cmp <= 0) 2393 return cmp; 2394 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2)); 2395 2396 case SAVE_EXPR: 2397 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2398 2399 case CALL_EXPR: 2400 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2401 if (cmp <= 0) 2402 return cmp; 2403 return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 2404 2405 case TARGET_EXPR: 2406 /* Special case: if either target is an unallocated VAR_DECL, 2407 it means that it's going to be unified with whatever the 2408 TARGET_EXPR is really supposed to initialize, so treat it 2409 as being equivalent to anything. */ 2410 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL 2411 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE 2412 && DECL_RTL (TREE_OPERAND (t1, 0)) == 0) 2413 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL 2414 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE 2415 && DECL_RTL (TREE_OPERAND (t2, 0)) == 0)) 2416 cmp = 1; 2417 else 2418 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2419 if (cmp <= 0) 2420 return cmp; 2421 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 2422 2423 case WITH_CLEANUP_EXPR: 2424 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2425 if (cmp <= 0) 2426 return cmp; 2427 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2)); 2428 2429 case COMPONENT_REF: 2430 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1)) 2431 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2432 return 0; 2433 2434 case VAR_DECL: 2435 case PARM_DECL: 2436 case CONST_DECL: 2437 case FUNCTION_DECL: 2438 return 0; 2439 2440 case TEMPLATE_PARM_INDEX: 2441 return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2) 2442 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2); 2443 2444 case SIZEOF_EXPR: 2445 case ALIGNOF_EXPR: 2446 if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0))) 2447 return 0; 2448 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
|
2258 return comptypes (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0), 1);
| 2449 return same_type_p (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
2259 break; 2260
| 2450 break; 2451
|
| 2452 case PTRMEM_CST: 2453 /* Two pointer-to-members are the same if they point to the same 2454 field or function in the same class. */ 2455 return (PTRMEM_CST_MEMBER (t1) == PTRMEM_CST_MEMBER (t2) 2456 && same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2))); 2457
|
2261 default: 2262 break; 2263 } 2264 2265 switch (TREE_CODE_CLASS (code1)) 2266 { 2267 int i; 2268 case '1': 2269 case '2': 2270 case '<': 2271 case 'e': 2272 case 'r': 2273 case 's': 2274 cmp = 1; 2275 for (i=0; i<tree_code_length[(int) code1]; ++i) 2276 { 2277 cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)); 2278 if (cmp <= 0) 2279 return cmp; 2280 } 2281 return cmp; 2282 } 2283 2284 return -1; 2285} 2286
| 2458 default: 2459 break; 2460 } 2461 2462 switch (TREE_CODE_CLASS (code1)) 2463 { 2464 int i; 2465 case '1': 2466 case '2': 2467 case '<': 2468 case 'e': 2469 case 'r': 2470 case 's': 2471 cmp = 1; 2472 for (i=0; i<tree_code_length[(int) code1]; ++i) 2473 { 2474 cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)); 2475 if (cmp <= 0) 2476 return cmp; 2477 } 2478 return cmp; 2479 } 2480 2481 return -1; 2482} 2483
|
2287/* Similar to make_tree_vec, but build on a temporary obstack. */
| 2484/* Similar to make_tree_vec, but build on the momentary_obstack. 2485 Thus, these vectors are really and truly temporary. */
|
2288 2289tree 2290make_temp_vec (len) 2291 int len; 2292{ 2293 register tree node;
| 2486 2487tree 2488make_temp_vec (len) 2489 int len; 2490{ 2491 register tree node;
|
2294 register struct obstack *ambient_obstack = current_obstack; 2295 current_obstack = expression_obstack;
| 2492 push_expression_obstack ();
|
2296 node = make_tree_vec (len);
| 2493 node = make_tree_vec (len);
|
2297 current_obstack = ambient_obstack;
| 2494 pop_obstacks ();
|
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; 2306{ 2307 tree t = make_node (WRAPPER); 2308 WRAPPER_PTR (t) = ptr; 2309 return t; 2310} 2311 2312/* Same, but on the expression_obstack. */ 2313 2314tree 2315build_expr_ptr_wrapper (ptr) 2316 void *ptr; 2317{ 2318 tree t; 2319 push_expression_obstack (); 2320 t = build_ptr_wrapper (ptr); 2321 pop_obstacks (); 2322 return t; 2323} 2324 2325/* Build a wrapper around some integer I so we can use it as a tree. */ 2326 2327tree 2328build_int_wrapper (i) 2329 int i; 2330{ 2331 tree t = make_node (WRAPPER); 2332 WRAPPER_INT (t) = i; 2333 return t; 2334} 2335
| 2495 return node; 2496} 2497 2498/* Build a wrapper around some pointer PTR so we can use it as a tree. */ 2499 2500tree 2501build_ptr_wrapper (ptr) 2502 void *ptr; 2503{ 2504 tree t = make_node (WRAPPER); 2505 WRAPPER_PTR (t) = ptr; 2506 return t; 2507} 2508 2509/* Same, but on the expression_obstack. */ 2510 2511tree 2512build_expr_ptr_wrapper (ptr) 2513 void *ptr; 2514{ 2515 tree t; 2516 push_expression_obstack (); 2517 t = build_ptr_wrapper (ptr); 2518 pop_obstacks (); 2519 return t; 2520} 2521 2522/* Build a wrapper around some integer I so we can use it as a tree. */ 2523 2524tree 2525build_int_wrapper (i) 2526 int i; 2527{ 2528 tree t = make_node (WRAPPER); 2529 WRAPPER_INT (t) = i; 2530 return t; 2531} 2532
|
2336tree
| 2533static tree
|
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, 2345 which also puts it on the permanent_obstack. However, this wasn't 2346 explicitly doing the same. */ 2347 register struct obstack *ambient_obstack = current_obstack; 2348 current_obstack = &permanent_obstack; 2349 2350 t = make_node (SRCLOC); 2351 SRCLOC_FILE (t) = file; 2352 SRCLOC_LINE (t) = line; 2353 2354 current_obstack = ambient_obstack; 2355 2356 return t; 2357} 2358 2359tree 2360build_srcloc_here () 2361{ 2362 return build_srcloc (input_filename, lineno); 2363} 2364 2365void 2366push_expression_obstack () 2367{ 2368 push_obstacks_nochange (); 2369 current_obstack = expression_obstack; 2370} 2371 2372/* The type of ARG when used as an lvalue. */ 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;
| 2534build_srcloc (file, line) 2535 char *file; 2536 int line; 2537{ 2538 tree t; 2539 2540 /* Make sure that we put these on the permanent obstack; up in 2541 add_pending_template, we pass this return value into perm_tree_cons, 2542 which also puts it on the permanent_obstack. However, this wasn't 2543 explicitly doing the same. */ 2544 register struct obstack *ambient_obstack = current_obstack; 2545 current_obstack = &permanent_obstack; 2546 2547 t = make_node (SRCLOC); 2548 SRCLOC_FILE (t) = file; 2549 SRCLOC_LINE (t) = line; 2550 2551 current_obstack = ambient_obstack; 2552 2553 return t; 2554} 2555 2556tree 2557build_srcloc_here () 2558{ 2559 return build_srcloc (input_filename, lineno); 2560} 2561 2562void 2563push_expression_obstack () 2564{ 2565 push_obstacks_nochange (); 2566 current_obstack = expression_obstack; 2567} 2568 2569/* The type of ARG when used as an lvalue. */ 2570 2571tree 2572lvalue_type (arg) 2573 tree arg; 2574{ 2575 tree type = TREE_TYPE (arg); 2576 if (TREE_CODE (arg) == OVERLOAD) 2577 type = unknown_type_node;
|
2381 return cp_build_type_variant 2382 (type, TREE_READONLY (arg), TREE_THIS_VOLATILE (arg));
| 2578 return type;
|
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; 2391{ 2392 tree type = TREE_TYPE (arg); 2393 if (TREE_CODE (type) == ARRAY_TYPE) 2394 ; 2395 else if (real_lvalue_p (arg)) 2396 type = build_reference_type (lvalue_type (arg)); 2397 else if (IS_AGGR_TYPE (type)) 2398 type = lvalue_type (arg); 2399 2400 return type; 2401} 2402 2403/* Does FUNCTION use a variable-length argument list? */ 2404 2405int 2406varargs_function_p (function) 2407 tree function; 2408{ 2409 tree parm = TYPE_ARG_TYPES (TREE_TYPE (function)); 2410 for (; parm; parm = TREE_CHAIN (parm)) 2411 if (TREE_VALUE (parm) == void_type_node) 2412 return 0; 2413 return 1; 2414} 2415 2416/* Returns 1 if decl is a member of a class. */ 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}
| 2579} 2580 2581/* The type of ARG for printing error messages; denote lvalues with 2582 reference types. */ 2583 2584tree 2585error_type (arg) 2586 tree arg; 2587{ 2588 tree type = TREE_TYPE (arg); 2589 if (TREE_CODE (type) == ARRAY_TYPE) 2590 ; 2591 else if (real_lvalue_p (arg)) 2592 type = build_reference_type (lvalue_type (arg)); 2593 else if (IS_AGGR_TYPE (type)) 2594 type = lvalue_type (arg); 2595 2596 return type; 2597} 2598 2599/* Does FUNCTION use a variable-length argument list? */ 2600 2601int 2602varargs_function_p (function) 2603 tree function; 2604{ 2605 tree parm = TYPE_ARG_TYPES (TREE_TYPE (function)); 2606 for (; parm; parm = TREE_CHAIN (parm)) 2607 if (TREE_VALUE (parm) == void_type_node) 2608 return 0; 2609 return 1; 2610} 2611 2612/* Returns 1 if decl is a member of a class. */ 2613 2614int 2615member_p (decl) 2616 tree decl; 2617{ 2618 tree ctx = DECL_CONTEXT (decl); 2619 return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't'); 2620}
|
| 2621 2622/* Create a placeholder for member access where we don't actually have an 2623 object that the access is against. */ 2624 2625tree 2626build_dummy_object (type) 2627 tree type; 2628{ 2629 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node); 2630 return build_indirect_ref (decl, NULL_PTR); 2631} 2632 2633/* We've gotten a reference to a member of TYPE. Return *this if appropriate, 2634 or a dummy object otherwise. If BINFOP is non-0, it is filled with the 2635 binfo path from current_class_type to TYPE, or 0. */ 2636 2637tree 2638maybe_dummy_object (type, binfop) 2639 tree type; 2640 tree *binfop; 2641{ 2642 tree decl, context; 2643 2644 if (current_class_type 2645 && get_base_distance (type, current_class_type, 0, binfop) != -1) 2646 context = current_class_type; 2647 else 2648 { 2649 /* Reference from a nested class member function. */ 2650 context = type; 2651 if (binfop) 2652 *binfop = TYPE_BINFO (type); 2653 } 2654 2655 if (current_class_ref && context == current_class_type) 2656 decl = current_class_ref; 2657 else 2658 decl = build_dummy_object (context); 2659 2660 return decl; 2661} 2662 2663/* Returns 1 if OB is a placeholder object, or a pointer to one. */ 2664 2665int 2666is_dummy_object (ob) 2667 tree ob; 2668{ 2669 if (TREE_CODE (ob) == INDIRECT_REF) 2670 ob = TREE_OPERAND (ob, 0); 2671 return (TREE_CODE (ob) == NOP_EXPR 2672 && TREE_OPERAND (ob, 0) == void_zero_node); 2673} 2674 2675/* Returns 1 iff type T is a POD type, as defined in [basic.types]. */ 2676 2677int 2678pod_type_p (t) 2679 tree t; 2680{ 2681 tree f; 2682 2683 while (TREE_CODE (t) == ARRAY_TYPE) 2684 t = TREE_TYPE (t); 2685 2686 if (! IS_AGGR_TYPE (t)) 2687 return 1; 2688 2689 if (CLASSTYPE_NON_AGGREGATE (t) 2690 || TYPE_HAS_COMPLEX_ASSIGN_REF (t) 2691 || TYPE_HAS_DESTRUCTOR (t)) 2692 return 0; 2693 2694 for (f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f)) 2695 { 2696 if (TREE_CODE (f) != FIELD_DECL) 2697 continue; 2698 2699 if (TREE_CODE (TREE_TYPE (f)) == REFERENCE_TYPE 2700 || TYPE_PTRMEMFUNC_P (TREE_TYPE (f)) 2701 || TYPE_PTRMEM_P (TREE_TYPE (f))) 2702 return 0; 2703 } 2704 2705 return 1; 2706} 2707 2708/* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid C++-specific 2709 attribute for either declaration DECL or type TYPE and 0 otherwise. 2710 Plugged into valid_lang_attribute. */ 2711 2712int 2713cp_valid_lang_attribute (attr_name, attr_args, decl, type) 2714 tree attr_name; 2715 tree attr_args ATTRIBUTE_UNUSED; 2716 tree decl ATTRIBUTE_UNUSED; 2717 tree type ATTRIBUTE_UNUSED; 2718{ 2719 if (is_attribute_p ("com_interface", attr_name)) 2720 { 2721 if (! flag_vtable_thunks) 2722 { 2723 error ("`com_interface' only supported with -fvtable-thunks"); 2724 return 0; 2725 } 2726 2727 if (attr_args != NULL_TREE 2728 || decl != NULL_TREE 2729 || ! CLASS_TYPE_P (type) 2730 || type != TYPE_MAIN_VARIANT (type)) 2731 { 2732 warning ("`com_interface' attribute can only be applied to class definitions"); 2733 return 0; 2734 } 2735 2736 CLASSTYPE_COM_INTERFACE (type) = 1; 2737 return 1; 2738 } 2739 else if (is_attribute_p ("init_priority", attr_name)) 2740 { 2741 tree initp_expr = (attr_args ? TREE_VALUE (attr_args): NULL_TREE); 2742 int pri; 2743 2744 if (initp_expr) 2745 STRIP_NOPS (initp_expr); 2746 2747 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST) 2748 { 2749 error ("requested init_priority is not an integer constant"); 2750 return 0; 2751 } 2752 2753 pri = TREE_INT_CST_LOW (initp_expr); 2754 2755 while (TREE_CODE (type) == ARRAY_TYPE) 2756 type = TREE_TYPE (type); 2757 2758 if (decl == NULL_TREE 2759 || TREE_CODE (decl) != VAR_DECL 2760 || ! TREE_STATIC (decl) 2761 || DECL_EXTERNAL (decl) 2762 || (TREE_CODE (type) != RECORD_TYPE 2763 && TREE_CODE (type) != UNION_TYPE) 2764 /* Static objects in functions are initialized the 2765 first time control passes through that 2766 function. This is not precise enough to pin down an 2767 init_priority value, so don't allow it. */ 2768 || current_function_decl) 2769 { 2770 error ("can only use init_priority attribute on file-scope definitions of objects of class type"); 2771 return 0; 2772 } 2773 2774 if (pri > MAX_INIT_PRIORITY || pri <= 0) 2775 { 2776 error ("requested init_priority is out of range"); 2777 return 0; 2778 } 2779 2780 /* Check for init_priorities that are reserved for 2781 language and runtime support implementations.*/ 2782 if (pri <= MAX_RESERVED_INIT_PRIORITY) 2783 { 2784 warning 2785 ("requested init_priority is reserved for internal use"); 2786 } 2787 2788 DECL_INIT_PRIORITY (decl) = pri; 2789 return 1; 2790 } 2791 2792 return 0; 2793} 2794 2795/* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the 2796 thing pointed to by the constant. */ 2797 2798tree 2799make_ptrmem_cst (type, member) 2800 tree type; 2801 tree member; 2802{ 2803 tree ptrmem_cst = make_node (PTRMEM_CST); 2804 /* If would seem a great convenience if make_node would set 2805 TREE_CONSTANT for things of class `c', but it does not. */ 2806 TREE_CONSTANT (ptrmem_cst) = 1; 2807 TREE_TYPE (ptrmem_cst) = type; 2808 PTRMEM_CST_MEMBER (ptrmem_cst) = member; 2809 return ptrmem_cst; 2810} 2811
|
| |