1 /* Language-independent node constructors for parse phase of GNU compiler. 2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 4 2011, 2012 Free Software Foundation, Inc. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 /* This file contains the low level primitives for operating on tree nodes, 23 including allocation, list operations, interning of identifiers, 24 construction of data type nodes and statement nodes, 25 and construction of type conversion nodes. It also contains 26 tables index by tree code that describe how to take apart 27 nodes of that code. 28 29 It is intended to be language-independent, but occasionally 30 calls language-dependent routines defined (for C) in typecheck.c. */ 31 32 #include "config.h" 33 #include "system.h" 34 #include "coretypes.h" 35 #include "tm.h" 36 #include "flags.h" 37 #include "tree.h" 38 #include "tm_p.h" 39 #include "function.h" 40 #include "obstack.h" 41 #include "toplev.h" 42 #include "ggc.h" 43 #include "hashtab.h" 44 #include "filenames.h" 45 #include "output.h" 46 #include "target.h" 47 #include "common/common-target.h" 48 #include "langhooks.h" 49 #include "tree-inline.h" 50 #include "tree-iterator.h" 51 #include "basic-block.h" 52 #include "tree-flow.h" 53 #include "params.h" 54 #include "pointer-set.h" 55 #include "tree-pass.h" 56 #include "langhooks-def.h" 57 #include "diagnostic.h" 58 #include "tree-diagnostic.h" 59 #include "tree-pretty-print.h" 60 #include "cgraph.h" 61 #include "timevar.h" 62 #include "except.h" 63 #include "debug.h" 64 #include "intl.h" 65 66 /* Tree code classes. */ 67 68 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE, 69 #define END_OF_BASE_TREE_CODES tcc_exceptional, 70 71 const enum tree_code_class tree_code_type[] = { 72 #include "all-tree.def" 73 }; 74 75 #undef DEFTREECODE 76 #undef END_OF_BASE_TREE_CODES 77 78 /* Table indexed by tree code giving number of expression 79 operands beyond the fixed part of the node structure. 80 Not used for types or decls. */ 81 82 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH, 83 #define END_OF_BASE_TREE_CODES 0, 84 85 const unsigned char tree_code_length[] = { 86 #include "all-tree.def" 87 }; 88 89 #undef DEFTREECODE 90 #undef END_OF_BASE_TREE_CODES 91 92 /* Names of tree components. 93 Used for printing out the tree and error messages. */ 94 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME, 95 #define END_OF_BASE_TREE_CODES "@dummy", 96 97 const char *const tree_code_name[] = { 98 #include "all-tree.def" 99 }; 100 101 #undef DEFTREECODE 102 #undef END_OF_BASE_TREE_CODES 103 104 /* Each tree code class has an associated string representation. 105 These must correspond to the tree_code_class entries. */ 106 107 const char *const tree_code_class_strings[] = 108 { 109 "exceptional", 110 "constant", 111 "type", 112 "declaration", 113 "reference", 114 "comparison", 115 "unary", 116 "binary", 117 "statement", 118 "vl_exp", 119 "expression" 120 }; 121 122 /* obstack.[ch] explicitly declined to prototype this. */ 123 extern int _obstack_allocated_p (struct obstack *h, void *obj); 124 125 #ifdef GATHER_STATISTICS 126 /* Statistics-gathering stuff. */ 127 128 static int tree_code_counts[MAX_TREE_CODES]; 129 int tree_node_counts[(int) all_kinds]; 130 int tree_node_sizes[(int) all_kinds]; 131 132 /* Keep in sync with tree.h:enum tree_node_kind. */ 133 static const char * const tree_node_kind_names[] = { 134 "decls", 135 "types", 136 "blocks", 137 "stmts", 138 "refs", 139 "exprs", 140 "constants", 141 "identifiers", 142 "vecs", 143 "binfos", 144 "ssa names", 145 "constructors", 146 "random kinds", 147 "lang_decl kinds", 148 "lang_type kinds", 149 "omp clauses", 150 }; 151 #endif /* GATHER_STATISTICS */ 152 153 /* Unique id for next decl created. */ 154 static GTY(()) int next_decl_uid; 155 /* Unique id for next type created. */ 156 static GTY(()) int next_type_uid = 1; 157 /* Unique id for next debug decl created. Use negative numbers, 158 to catch erroneous uses. */ 159 static GTY(()) int next_debug_decl_uid; 160 161 /* Since we cannot rehash a type after it is in the table, we have to 162 keep the hash code. */ 163 164 struct GTY(()) type_hash { 165 unsigned long hash; 166 tree type; 167 }; 168 169 /* Initial size of the hash table (rounded to next prime). */ 170 #define TYPE_HASH_INITIAL_SIZE 1000 171 172 /* Now here is the hash table. When recording a type, it is added to 173 the slot whose index is the hash code. Note that the hash table is 174 used for several kinds of types (function types, array types and 175 array index range types, for now). While all these live in the 176 same table, they are completely independent, and the hash code is 177 computed differently for each of these. */ 178 179 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash))) 180 htab_t type_hash_table; 181 182 /* Hash table and temporary node for larger integer const values. */ 183 static GTY (()) tree int_cst_node; 184 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node))) 185 htab_t int_cst_hash_table; 186 187 /* Hash table for optimization flags and target option flags. Use the same 188 hash table for both sets of options. Nodes for building the current 189 optimization and target option nodes. The assumption is most of the time 190 the options created will already be in the hash table, so we avoid 191 allocating and freeing up a node repeatably. */ 192 static GTY (()) tree cl_optimization_node; 193 static GTY (()) tree cl_target_option_node; 194 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node))) 195 htab_t cl_option_hash_table; 196 197 /* General tree->tree mapping structure for use in hash tables. */ 198 199 200 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map))) 201 htab_t debug_expr_for_decl; 202 203 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map))) 204 htab_t value_expr_for_decl; 205 206 static GTY ((if_marked ("tree_vec_map_marked_p"), param_is (struct tree_vec_map))) 207 htab_t debug_args_for_decl; 208 209 static GTY ((if_marked ("tree_priority_map_marked_p"), 210 param_is (struct tree_priority_map))) 211 htab_t init_priority_for_decl; 212 213 static void set_type_quals (tree, int); 214 static int type_hash_eq (const void *, const void *); 215 static hashval_t type_hash_hash (const void *); 216 static hashval_t int_cst_hash_hash (const void *); 217 static int int_cst_hash_eq (const void *, const void *); 218 static hashval_t cl_option_hash_hash (const void *); 219 static int cl_option_hash_eq (const void *, const void *); 220 static void print_type_hash_statistics (void); 221 static void print_debug_expr_statistics (void); 222 static void print_value_expr_statistics (void); 223 static int type_hash_marked_p (const void *); 224 static unsigned int type_hash_list (const_tree, hashval_t); 225 static unsigned int attribute_hash_list (const_tree, hashval_t); 226 227 tree global_trees[TI_MAX]; 228 tree integer_types[itk_none]; 229 230 unsigned char tree_contains_struct[MAX_TREE_CODES][64]; 231 232 /* Number of operands for each OpenMP clause. */ 233 unsigned const char omp_clause_num_ops[] = 234 { 235 0, /* OMP_CLAUSE_ERROR */ 236 1, /* OMP_CLAUSE_PRIVATE */ 237 1, /* OMP_CLAUSE_SHARED */ 238 1, /* OMP_CLAUSE_FIRSTPRIVATE */ 239 2, /* OMP_CLAUSE_LASTPRIVATE */ 240 4, /* OMP_CLAUSE_REDUCTION */ 241 1, /* OMP_CLAUSE_COPYIN */ 242 1, /* OMP_CLAUSE_COPYPRIVATE */ 243 1, /* OMP_CLAUSE_IF */ 244 1, /* OMP_CLAUSE_NUM_THREADS */ 245 1, /* OMP_CLAUSE_SCHEDULE */ 246 0, /* OMP_CLAUSE_NOWAIT */ 247 0, /* OMP_CLAUSE_ORDERED */ 248 0, /* OMP_CLAUSE_DEFAULT */ 249 3, /* OMP_CLAUSE_COLLAPSE */ 250 0, /* OMP_CLAUSE_UNTIED */ 251 1, /* OMP_CLAUSE_FINAL */ 252 0 /* OMP_CLAUSE_MERGEABLE */ 253 }; 254 255 const char * const omp_clause_code_name[] = 256 { 257 "error_clause", 258 "private", 259 "shared", 260 "firstprivate", 261 "lastprivate", 262 "reduction", 263 "copyin", 264 "copyprivate", 265 "if", 266 "num_threads", 267 "schedule", 268 "nowait", 269 "ordered", 270 "default", 271 "collapse", 272 "untied", 273 "final", 274 "mergeable" 275 }; 276 277 278 /* Return the tree node structure used by tree code CODE. */ 279 280 static inline enum tree_node_structure_enum 281 tree_node_structure_for_code (enum tree_code code) 282 { 283 switch (TREE_CODE_CLASS (code)) 284 { 285 case tcc_declaration: 286 { 287 switch (code) 288 { 289 case FIELD_DECL: 290 return TS_FIELD_DECL; 291 case PARM_DECL: 292 return TS_PARM_DECL; 293 case VAR_DECL: 294 return TS_VAR_DECL; 295 case LABEL_DECL: 296 return TS_LABEL_DECL; 297 case RESULT_DECL: 298 return TS_RESULT_DECL; 299 case DEBUG_EXPR_DECL: 300 return TS_DECL_WRTL; 301 case CONST_DECL: 302 return TS_CONST_DECL; 303 case TYPE_DECL: 304 return TS_TYPE_DECL; 305 case FUNCTION_DECL: 306 return TS_FUNCTION_DECL; 307 case TRANSLATION_UNIT_DECL: 308 return TS_TRANSLATION_UNIT_DECL; 309 default: 310 return TS_DECL_NON_COMMON; 311 } 312 } 313 case tcc_type: 314 return TS_TYPE_NON_COMMON; 315 case tcc_reference: 316 case tcc_comparison: 317 case tcc_unary: 318 case tcc_binary: 319 case tcc_expression: 320 case tcc_statement: 321 case tcc_vl_exp: 322 return TS_EXP; 323 default: /* tcc_constant and tcc_exceptional */ 324 break; 325 } 326 switch (code) 327 { 328 /* tcc_constant cases. */ 329 case INTEGER_CST: return TS_INT_CST; 330 case REAL_CST: return TS_REAL_CST; 331 case FIXED_CST: return TS_FIXED_CST; 332 case COMPLEX_CST: return TS_COMPLEX; 333 case VECTOR_CST: return TS_VECTOR; 334 case STRING_CST: return TS_STRING; 335 /* tcc_exceptional cases. */ 336 case ERROR_MARK: return TS_COMMON; 337 case IDENTIFIER_NODE: return TS_IDENTIFIER; 338 case TREE_LIST: return TS_LIST; 339 case TREE_VEC: return TS_VEC; 340 case SSA_NAME: return TS_SSA_NAME; 341 case PLACEHOLDER_EXPR: return TS_COMMON; 342 case STATEMENT_LIST: return TS_STATEMENT_LIST; 343 case BLOCK: return TS_BLOCK; 344 case CONSTRUCTOR: return TS_CONSTRUCTOR; 345 case TREE_BINFO: return TS_BINFO; 346 case OMP_CLAUSE: return TS_OMP_CLAUSE; 347 case OPTIMIZATION_NODE: return TS_OPTIMIZATION; 348 case TARGET_OPTION_NODE: return TS_TARGET_OPTION; 349 350 default: 351 gcc_unreachable (); 352 } 353 } 354 355 356 /* Initialize tree_contains_struct to describe the hierarchy of tree 357 nodes. */ 358 359 static void 360 initialize_tree_contains_struct (void) 361 { 362 unsigned i; 363 364 for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++) 365 { 366 enum tree_code code; 367 enum tree_node_structure_enum ts_code; 368 369 code = (enum tree_code) i; 370 ts_code = tree_node_structure_for_code (code); 371 372 /* Mark the TS structure itself. */ 373 tree_contains_struct[code][ts_code] = 1; 374 375 /* Mark all the structures that TS is derived from. */ 376 switch (ts_code) 377 { 378 case TS_TYPED: 379 case TS_BLOCK: 380 MARK_TS_BASE (code); 381 break; 382 383 case TS_COMMON: 384 case TS_INT_CST: 385 case TS_REAL_CST: 386 case TS_FIXED_CST: 387 case TS_VECTOR: 388 case TS_STRING: 389 case TS_COMPLEX: 390 case TS_SSA_NAME: 391 case TS_CONSTRUCTOR: 392 case TS_EXP: 393 case TS_STATEMENT_LIST: 394 MARK_TS_TYPED (code); 395 break; 396 397 case TS_IDENTIFIER: 398 case TS_DECL_MINIMAL: 399 case TS_TYPE_COMMON: 400 case TS_LIST: 401 case TS_VEC: 402 case TS_BINFO: 403 case TS_OMP_CLAUSE: 404 case TS_OPTIMIZATION: 405 case TS_TARGET_OPTION: 406 MARK_TS_COMMON (code); 407 break; 408 409 case TS_TYPE_WITH_LANG_SPECIFIC: 410 MARK_TS_TYPE_COMMON (code); 411 break; 412 413 case TS_TYPE_NON_COMMON: 414 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code); 415 break; 416 417 case TS_DECL_COMMON: 418 MARK_TS_DECL_MINIMAL (code); 419 break; 420 421 case TS_DECL_WRTL: 422 case TS_CONST_DECL: 423 MARK_TS_DECL_COMMON (code); 424 break; 425 426 case TS_DECL_NON_COMMON: 427 MARK_TS_DECL_WITH_VIS (code); 428 break; 429 430 case TS_DECL_WITH_VIS: 431 case TS_PARM_DECL: 432 case TS_LABEL_DECL: 433 case TS_RESULT_DECL: 434 MARK_TS_DECL_WRTL (code); 435 break; 436 437 case TS_FIELD_DECL: 438 MARK_TS_DECL_COMMON (code); 439 break; 440 441 case TS_VAR_DECL: 442 MARK_TS_DECL_WITH_VIS (code); 443 break; 444 445 case TS_TYPE_DECL: 446 case TS_FUNCTION_DECL: 447 MARK_TS_DECL_NON_COMMON (code); 448 break; 449 450 case TS_TRANSLATION_UNIT_DECL: 451 MARK_TS_DECL_COMMON (code); 452 break; 453 454 default: 455 gcc_unreachable (); 456 } 457 } 458 459 /* Basic consistency checks for attributes used in fold. */ 460 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]); 461 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]); 462 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]); 463 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]); 464 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]); 465 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]); 466 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]); 467 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]); 468 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]); 469 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]); 470 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]); 471 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]); 472 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]); 473 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]); 474 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]); 475 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]); 476 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]); 477 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]); 478 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]); 479 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]); 480 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]); 481 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]); 482 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]); 483 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]); 484 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]); 485 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]); 486 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]); 487 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]); 488 gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]); 489 gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]); 490 gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]); 491 gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]); 492 gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]); 493 gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]); 494 gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]); 495 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]); 496 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]); 497 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]); 498 } 499 500 501 /* Init tree.c. */ 502 503 void 504 init_ttree (void) 505 { 506 /* Initialize the hash table of types. */ 507 type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash, 508 type_hash_eq, 0); 509 510 debug_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash, 511 tree_decl_map_eq, 0); 512 513 value_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash, 514 tree_decl_map_eq, 0); 515 init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash, 516 tree_priority_map_eq, 0); 517 518 int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash, 519 int_cst_hash_eq, NULL); 520 521 int_cst_node = make_node (INTEGER_CST); 522 523 cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash, 524 cl_option_hash_eq, NULL); 525 526 cl_optimization_node = make_node (OPTIMIZATION_NODE); 527 cl_target_option_node = make_node (TARGET_OPTION_NODE); 528 529 /* Initialize the tree_contains_struct array. */ 530 initialize_tree_contains_struct (); 531 lang_hooks.init_ts (); 532 } 533 534 535 /* The name of the object as the assembler will see it (but before any 536 translations made by ASM_OUTPUT_LABELREF). Often this is the same 537 as DECL_NAME. It is an IDENTIFIER_NODE. */ 538 tree 539 decl_assembler_name (tree decl) 540 { 541 if (!DECL_ASSEMBLER_NAME_SET_P (decl)) 542 lang_hooks.set_decl_assembler_name (decl); 543 return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name; 544 } 545 546 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */ 547 548 bool 549 decl_assembler_name_equal (tree decl, const_tree asmname) 550 { 551 tree decl_asmname = DECL_ASSEMBLER_NAME (decl); 552 const char *decl_str; 553 const char *asmname_str; 554 bool test = false; 555 556 if (decl_asmname == asmname) 557 return true; 558 559 decl_str = IDENTIFIER_POINTER (decl_asmname); 560 asmname_str = IDENTIFIER_POINTER (asmname); 561 562 563 /* If the target assembler name was set by the user, things are trickier. 564 We have a leading '*' to begin with. After that, it's arguable what 565 is the correct thing to do with -fleading-underscore. Arguably, we've 566 historically been doing the wrong thing in assemble_alias by always 567 printing the leading underscore. Since we're not changing that, make 568 sure user_label_prefix follows the '*' before matching. */ 569 if (decl_str[0] == '*') 570 { 571 size_t ulp_len = strlen (user_label_prefix); 572 573 decl_str ++; 574 575 if (ulp_len == 0) 576 test = true; 577 else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0) 578 decl_str += ulp_len, test=true; 579 else 580 decl_str --; 581 } 582 if (asmname_str[0] == '*') 583 { 584 size_t ulp_len = strlen (user_label_prefix); 585 586 asmname_str ++; 587 588 if (ulp_len == 0) 589 test = true; 590 else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0) 591 asmname_str += ulp_len, test=true; 592 else 593 asmname_str --; 594 } 595 596 if (!test) 597 return false; 598 return strcmp (decl_str, asmname_str) == 0; 599 } 600 601 /* Hash asmnames ignoring the user specified marks. */ 602 603 hashval_t 604 decl_assembler_name_hash (const_tree asmname) 605 { 606 if (IDENTIFIER_POINTER (asmname)[0] == '*') 607 { 608 const char *decl_str = IDENTIFIER_POINTER (asmname) + 1; 609 size_t ulp_len = strlen (user_label_prefix); 610 611 if (ulp_len == 0) 612 ; 613 else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0) 614 decl_str += ulp_len; 615 616 return htab_hash_string (decl_str); 617 } 618 619 return htab_hash_string (IDENTIFIER_POINTER (asmname)); 620 } 621 622 /* Compute the number of bytes occupied by a tree with code CODE. 623 This function cannot be used for nodes that have variable sizes, 624 including TREE_VEC, STRING_CST, and CALL_EXPR. */ 625 size_t 626 tree_code_size (enum tree_code code) 627 { 628 switch (TREE_CODE_CLASS (code)) 629 { 630 case tcc_declaration: /* A decl node */ 631 { 632 switch (code) 633 { 634 case FIELD_DECL: 635 return sizeof (struct tree_field_decl); 636 case PARM_DECL: 637 return sizeof (struct tree_parm_decl); 638 case VAR_DECL: 639 return sizeof (struct tree_var_decl); 640 case LABEL_DECL: 641 return sizeof (struct tree_label_decl); 642 case RESULT_DECL: 643 return sizeof (struct tree_result_decl); 644 case CONST_DECL: 645 return sizeof (struct tree_const_decl); 646 case TYPE_DECL: 647 return sizeof (struct tree_type_decl); 648 case FUNCTION_DECL: 649 return sizeof (struct tree_function_decl); 650 case DEBUG_EXPR_DECL: 651 return sizeof (struct tree_decl_with_rtl); 652 default: 653 return sizeof (struct tree_decl_non_common); 654 } 655 } 656 657 case tcc_type: /* a type node */ 658 return sizeof (struct tree_type_non_common); 659 660 case tcc_reference: /* a reference */ 661 case tcc_expression: /* an expression */ 662 case tcc_statement: /* an expression with side effects */ 663 case tcc_comparison: /* a comparison expression */ 664 case tcc_unary: /* a unary arithmetic expression */ 665 case tcc_binary: /* a binary arithmetic expression */ 666 return (sizeof (struct tree_exp) 667 + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree)); 668 669 case tcc_constant: /* a constant */ 670 switch (code) 671 { 672 case INTEGER_CST: return sizeof (struct tree_int_cst); 673 case REAL_CST: return sizeof (struct tree_real_cst); 674 case FIXED_CST: return sizeof (struct tree_fixed_cst); 675 case COMPLEX_CST: return sizeof (struct tree_complex); 676 case VECTOR_CST: return sizeof (struct tree_vector); 677 case STRING_CST: gcc_unreachable (); 678 default: 679 return lang_hooks.tree_size (code); 680 } 681 682 case tcc_exceptional: /* something random, like an identifier. */ 683 switch (code) 684 { 685 case IDENTIFIER_NODE: return lang_hooks.identifier_size; 686 case TREE_LIST: return sizeof (struct tree_list); 687 688 case ERROR_MARK: 689 case PLACEHOLDER_EXPR: return sizeof (struct tree_common); 690 691 case TREE_VEC: 692 case OMP_CLAUSE: gcc_unreachable (); 693 694 case SSA_NAME: return sizeof (struct tree_ssa_name); 695 696 case STATEMENT_LIST: return sizeof (struct tree_statement_list); 697 case BLOCK: return sizeof (struct tree_block); 698 case CONSTRUCTOR: return sizeof (struct tree_constructor); 699 case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option); 700 case TARGET_OPTION_NODE: return sizeof (struct tree_target_option); 701 702 default: 703 return lang_hooks.tree_size (code); 704 } 705 706 default: 707 gcc_unreachable (); 708 } 709 } 710 711 /* Compute the number of bytes occupied by NODE. This routine only 712 looks at TREE_CODE, except for those nodes that have variable sizes. */ 713 size_t 714 tree_size (const_tree node) 715 { 716 const enum tree_code code = TREE_CODE (node); 717 switch (code) 718 { 719 case TREE_BINFO: 720 return (offsetof (struct tree_binfo, base_binfos) 721 + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node))); 722 723 case TREE_VEC: 724 return (sizeof (struct tree_vec) 725 + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree)); 726 727 case STRING_CST: 728 return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1; 729 730 case OMP_CLAUSE: 731 return (sizeof (struct tree_omp_clause) 732 + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1) 733 * sizeof (tree)); 734 735 default: 736 if (TREE_CODE_CLASS (code) == tcc_vl_exp) 737 return (sizeof (struct tree_exp) 738 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree)); 739 else 740 return tree_code_size (code); 741 } 742 } 743 744 /* Record interesting allocation statistics for a tree node with CODE 745 and LENGTH. */ 746 747 static void 748 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED, 749 size_t length ATTRIBUTE_UNUSED) 750 { 751 #ifdef GATHER_STATISTICS 752 enum tree_code_class type = TREE_CODE_CLASS (code); 753 tree_node_kind kind; 754 755 switch (type) 756 { 757 case tcc_declaration: /* A decl node */ 758 kind = d_kind; 759 break; 760 761 case tcc_type: /* a type node */ 762 kind = t_kind; 763 break; 764 765 case tcc_statement: /* an expression with side effects */ 766 kind = s_kind; 767 break; 768 769 case tcc_reference: /* a reference */ 770 kind = r_kind; 771 break; 772 773 case tcc_expression: /* an expression */ 774 case tcc_comparison: /* a comparison expression */ 775 case tcc_unary: /* a unary arithmetic expression */ 776 case tcc_binary: /* a binary arithmetic expression */ 777 kind = e_kind; 778 break; 779 780 case tcc_constant: /* a constant */ 781 kind = c_kind; 782 break; 783 784 case tcc_exceptional: /* something random, like an identifier. */ 785 switch (code) 786 { 787 case IDENTIFIER_NODE: 788 kind = id_kind; 789 break; 790 791 case TREE_VEC: 792 kind = vec_kind; 793 break; 794 795 case TREE_BINFO: 796 kind = binfo_kind; 797 break; 798 799 case SSA_NAME: 800 kind = ssa_name_kind; 801 break; 802 803 case BLOCK: 804 kind = b_kind; 805 break; 806 807 case CONSTRUCTOR: 808 kind = constr_kind; 809 break; 810 811 case OMP_CLAUSE: 812 kind = omp_clause_kind; 813 break; 814 815 default: 816 kind = x_kind; 817 break; 818 } 819 break; 820 821 case tcc_vl_exp: 822 kind = e_kind; 823 break; 824 825 default: 826 gcc_unreachable (); 827 } 828 829 tree_code_counts[(int) code]++; 830 tree_node_counts[(int) kind]++; 831 tree_node_sizes[(int) kind] += length; 832 #endif 833 } 834 835 /* Allocate and return a new UID from the DECL_UID namespace. */ 836 837 int 838 allocate_decl_uid (void) 839 { 840 return next_decl_uid++; 841 } 842 843 /* Return a newly allocated node of code CODE. For decl and type 844 nodes, some other fields are initialized. The rest of the node is 845 initialized to zero. This function cannot be used for TREE_VEC or 846 OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size. 847 848 Achoo! I got a code in the node. */ 849 850 tree 851 make_node_stat (enum tree_code code MEM_STAT_DECL) 852 { 853 tree t; 854 enum tree_code_class type = TREE_CODE_CLASS (code); 855 size_t length = tree_code_size (code); 856 857 record_node_allocation_statistics (code, length); 858 859 t = ggc_alloc_zone_cleared_tree_node_stat ( 860 (code == IDENTIFIER_NODE) ? &tree_id_zone : &tree_zone, 861 length PASS_MEM_STAT); 862 TREE_SET_CODE (t, code); 863 864 switch (type) 865 { 866 case tcc_statement: 867 TREE_SIDE_EFFECTS (t) = 1; 868 break; 869 870 case tcc_declaration: 871 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 872 { 873 if (code == FUNCTION_DECL) 874 { 875 DECL_ALIGN (t) = FUNCTION_BOUNDARY; 876 DECL_MODE (t) = FUNCTION_MODE; 877 } 878 else 879 DECL_ALIGN (t) = 1; 880 } 881 DECL_SOURCE_LOCATION (t) = input_location; 882 if (TREE_CODE (t) == DEBUG_EXPR_DECL) 883 DECL_UID (t) = --next_debug_decl_uid; 884 else 885 { 886 DECL_UID (t) = allocate_decl_uid (); 887 SET_DECL_PT_UID (t, -1); 888 } 889 if (TREE_CODE (t) == LABEL_DECL) 890 LABEL_DECL_UID (t) = -1; 891 892 break; 893 894 case tcc_type: 895 TYPE_UID (t) = next_type_uid++; 896 TYPE_ALIGN (t) = BITS_PER_UNIT; 897 TYPE_USER_ALIGN (t) = 0; 898 TYPE_MAIN_VARIANT (t) = t; 899 TYPE_CANONICAL (t) = t; 900 901 /* Default to no attributes for type, but let target change that. */ 902 TYPE_ATTRIBUTES (t) = NULL_TREE; 903 targetm.set_default_type_attributes (t); 904 905 /* We have not yet computed the alias set for this type. */ 906 TYPE_ALIAS_SET (t) = -1; 907 break; 908 909 case tcc_constant: 910 TREE_CONSTANT (t) = 1; 911 break; 912 913 case tcc_expression: 914 switch (code) 915 { 916 case INIT_EXPR: 917 case MODIFY_EXPR: 918 case VA_ARG_EXPR: 919 case PREDECREMENT_EXPR: 920 case PREINCREMENT_EXPR: 921 case POSTDECREMENT_EXPR: 922 case POSTINCREMENT_EXPR: 923 /* All of these have side-effects, no matter what their 924 operands are. */ 925 TREE_SIDE_EFFECTS (t) = 1; 926 break; 927 928 default: 929 break; 930 } 931 break; 932 933 default: 934 /* Other classes need no special treatment. */ 935 break; 936 } 937 938 return t; 939 } 940 941 /* Return a new node with the same contents as NODE except that its 942 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */ 943 944 tree 945 copy_node_stat (tree node MEM_STAT_DECL) 946 { 947 tree t; 948 enum tree_code code = TREE_CODE (node); 949 size_t length; 950 951 gcc_assert (code != STATEMENT_LIST); 952 953 length = tree_size (node); 954 record_node_allocation_statistics (code, length); 955 t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT); 956 memcpy (t, node, length); 957 958 if (CODE_CONTAINS_STRUCT (code, TS_COMMON)) 959 TREE_CHAIN (t) = 0; 960 TREE_ASM_WRITTEN (t) = 0; 961 TREE_VISITED (t) = 0; 962 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL) 963 *DECL_VAR_ANN_PTR (t) = 0; 964 965 if (TREE_CODE_CLASS (code) == tcc_declaration) 966 { 967 if (code == DEBUG_EXPR_DECL) 968 DECL_UID (t) = --next_debug_decl_uid; 969 else 970 { 971 DECL_UID (t) = allocate_decl_uid (); 972 if (DECL_PT_UID_SET_P (node)) 973 SET_DECL_PT_UID (t, DECL_PT_UID (node)); 974 } 975 if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL) 976 && DECL_HAS_VALUE_EXPR_P (node)) 977 { 978 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node)); 979 DECL_HAS_VALUE_EXPR_P (t) = 1; 980 } 981 if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node)) 982 { 983 SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node)); 984 DECL_HAS_INIT_PRIORITY_P (t) = 1; 985 } 986 } 987 else if (TREE_CODE_CLASS (code) == tcc_type) 988 { 989 TYPE_UID (t) = next_type_uid++; 990 /* The following is so that the debug code for 991 the copy is different from the original type. 992 The two statements usually duplicate each other 993 (because they clear fields of the same union), 994 but the optimizer should catch that. */ 995 TYPE_SYMTAB_POINTER (t) = 0; 996 TYPE_SYMTAB_ADDRESS (t) = 0; 997 998 /* Do not copy the values cache. */ 999 if (TYPE_CACHED_VALUES_P(t)) 1000 { 1001 TYPE_CACHED_VALUES_P (t) = 0; 1002 TYPE_CACHED_VALUES (t) = NULL_TREE; 1003 } 1004 } 1005 1006 return t; 1007 } 1008 1009 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field. 1010 For example, this can copy a list made of TREE_LIST nodes. */ 1011 1012 tree 1013 copy_list (tree list) 1014 { 1015 tree head; 1016 tree prev, next; 1017 1018 if (list == 0) 1019 return 0; 1020 1021 head = prev = copy_node (list); 1022 next = TREE_CHAIN (list); 1023 while (next) 1024 { 1025 TREE_CHAIN (prev) = copy_node (next); 1026 prev = TREE_CHAIN (prev); 1027 next = TREE_CHAIN (next); 1028 } 1029 return head; 1030 } 1031 1032 1033 /* Create an INT_CST node with a LOW value sign extended to TYPE. */ 1034 1035 tree 1036 build_int_cst (tree type, HOST_WIDE_INT low) 1037 { 1038 /* Support legacy code. */ 1039 if (!type) 1040 type = integer_type_node; 1041 1042 return double_int_to_tree (type, shwi_to_double_int (low)); 1043 } 1044 1045 /* Create an INT_CST node with a LOW value sign extended to TYPE. */ 1046 1047 tree 1048 build_int_cst_type (tree type, HOST_WIDE_INT low) 1049 { 1050 gcc_assert (type); 1051 1052 return double_int_to_tree (type, shwi_to_double_int (low)); 1053 } 1054 1055 /* Constructs tree in type TYPE from with value given by CST. Signedness 1056 of CST is assumed to be the same as the signedness of TYPE. */ 1057 1058 tree 1059 double_int_to_tree (tree type, double_int cst) 1060 { 1061 /* Size types *are* sign extended. */ 1062 bool sign_extended_type = (!TYPE_UNSIGNED (type) 1063 || (TREE_CODE (type) == INTEGER_TYPE 1064 && TYPE_IS_SIZETYPE (type))); 1065 1066 cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type); 1067 1068 return build_int_cst_wide (type, cst.low, cst.high); 1069 } 1070 1071 /* Returns true if CST fits into range of TYPE. Signedness of CST is assumed 1072 to be the same as the signedness of TYPE. */ 1073 1074 bool 1075 double_int_fits_to_tree_p (const_tree type, double_int cst) 1076 { 1077 /* Size types *are* sign extended. */ 1078 bool sign_extended_type = (!TYPE_UNSIGNED (type) 1079 || (TREE_CODE (type) == INTEGER_TYPE 1080 && TYPE_IS_SIZETYPE (type))); 1081 1082 double_int ext 1083 = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type); 1084 1085 return double_int_equal_p (cst, ext); 1086 } 1087 1088 /* We force the double_int CST to the range of the type TYPE by sign or 1089 zero extending it. OVERFLOWABLE indicates if we are interested in 1090 overflow of the value, when >0 we are only interested in signed 1091 overflow, for <0 we are interested in any overflow. OVERFLOWED 1092 indicates whether overflow has already occurred. CONST_OVERFLOWED 1093 indicates whether constant overflow has already occurred. We force 1094 T's value to be within range of T's type (by setting to 0 or 1 all 1095 the bits outside the type's range). We set TREE_OVERFLOWED if, 1096 OVERFLOWED is nonzero, 1097 or OVERFLOWABLE is >0 and signed overflow occurs 1098 or OVERFLOWABLE is <0 and any overflow occurs 1099 We return a new tree node for the extended double_int. The node 1100 is shared if no overflow flags are set. */ 1101 1102 1103 tree 1104 force_fit_type_double (tree type, double_int cst, int overflowable, 1105 bool overflowed) 1106 { 1107 bool sign_extended_type; 1108 1109 /* Size types *are* sign extended. */ 1110 sign_extended_type = (!TYPE_UNSIGNED (type) 1111 || (TREE_CODE (type) == INTEGER_TYPE 1112 && TYPE_IS_SIZETYPE (type))); 1113 1114 /* If we need to set overflow flags, return a new unshared node. */ 1115 if (overflowed || !double_int_fits_to_tree_p(type, cst)) 1116 { 1117 if (overflowed 1118 || overflowable < 0 1119 || (overflowable > 0 && sign_extended_type)) 1120 { 1121 tree t = make_node (INTEGER_CST); 1122 TREE_INT_CST (t) = double_int_ext (cst, TYPE_PRECISION (type), 1123 !sign_extended_type); 1124 TREE_TYPE (t) = type; 1125 TREE_OVERFLOW (t) = 1; 1126 return t; 1127 } 1128 } 1129 1130 /* Else build a shared node. */ 1131 return double_int_to_tree (type, cst); 1132 } 1133 1134 /* These are the hash table functions for the hash table of INTEGER_CST 1135 nodes of a sizetype. */ 1136 1137 /* Return the hash code code X, an INTEGER_CST. */ 1138 1139 static hashval_t 1140 int_cst_hash_hash (const void *x) 1141 { 1142 const_tree const t = (const_tree) x; 1143 1144 return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t) 1145 ^ htab_hash_pointer (TREE_TYPE (t))); 1146 } 1147 1148 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node) 1149 is the same as that given by *Y, which is the same. */ 1150 1151 static int 1152 int_cst_hash_eq (const void *x, const void *y) 1153 { 1154 const_tree const xt = (const_tree) x; 1155 const_tree const yt = (const_tree) y; 1156 1157 return (TREE_TYPE (xt) == TREE_TYPE (yt) 1158 && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt) 1159 && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt)); 1160 } 1161 1162 /* Create an INT_CST node of TYPE and value HI:LOW. 1163 The returned node is always shared. For small integers we use a 1164 per-type vector cache, for larger ones we use a single hash table. */ 1165 1166 tree 1167 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi) 1168 { 1169 tree t; 1170 int ix = -1; 1171 int limit = 0; 1172 1173 gcc_assert (type); 1174 1175 switch (TREE_CODE (type)) 1176 { 1177 case NULLPTR_TYPE: 1178 gcc_assert (hi == 0 && low == 0); 1179 /* Fallthru. */ 1180 1181 case POINTER_TYPE: 1182 case REFERENCE_TYPE: 1183 /* Cache NULL pointer. */ 1184 if (!hi && !low) 1185 { 1186 limit = 1; 1187 ix = 0; 1188 } 1189 break; 1190 1191 case BOOLEAN_TYPE: 1192 /* Cache false or true. */ 1193 limit = 2; 1194 if (!hi && low < 2) 1195 ix = low; 1196 break; 1197 1198 case INTEGER_TYPE: 1199 case OFFSET_TYPE: 1200 if (TYPE_UNSIGNED (type)) 1201 { 1202 /* Cache 0..N */ 1203 limit = INTEGER_SHARE_LIMIT; 1204 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT) 1205 ix = low; 1206 } 1207 else 1208 { 1209 /* Cache -1..N */ 1210 limit = INTEGER_SHARE_LIMIT + 1; 1211 if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT) 1212 ix = low + 1; 1213 else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1) 1214 ix = 0; 1215 } 1216 break; 1217 1218 case ENUMERAL_TYPE: 1219 break; 1220 1221 default: 1222 gcc_unreachable (); 1223 } 1224 1225 if (ix >= 0) 1226 { 1227 /* Look for it in the type's vector of small shared ints. */ 1228 if (!TYPE_CACHED_VALUES_P (type)) 1229 { 1230 TYPE_CACHED_VALUES_P (type) = 1; 1231 TYPE_CACHED_VALUES (type) = make_tree_vec (limit); 1232 } 1233 1234 t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix); 1235 if (t) 1236 { 1237 /* Make sure no one is clobbering the shared constant. */ 1238 gcc_assert (TREE_TYPE (t) == type); 1239 gcc_assert (TREE_INT_CST_LOW (t) == low); 1240 gcc_assert (TREE_INT_CST_HIGH (t) == hi); 1241 } 1242 else 1243 { 1244 /* Create a new shared int. */ 1245 t = make_node (INTEGER_CST); 1246 1247 TREE_INT_CST_LOW (t) = low; 1248 TREE_INT_CST_HIGH (t) = hi; 1249 TREE_TYPE (t) = type; 1250 1251 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t; 1252 } 1253 } 1254 else 1255 { 1256 /* Use the cache of larger shared ints. */ 1257 void **slot; 1258 1259 TREE_INT_CST_LOW (int_cst_node) = low; 1260 TREE_INT_CST_HIGH (int_cst_node) = hi; 1261 TREE_TYPE (int_cst_node) = type; 1262 1263 slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT); 1264 t = (tree) *slot; 1265 if (!t) 1266 { 1267 /* Insert this one into the hash table. */ 1268 t = int_cst_node; 1269 *slot = t; 1270 /* Make a new node for next time round. */ 1271 int_cst_node = make_node (INTEGER_CST); 1272 } 1273 } 1274 1275 return t; 1276 } 1277 1278 /* Builds an integer constant in TYPE such that lowest BITS bits are ones 1279 and the rest are zeros. */ 1280 1281 tree 1282 build_low_bits_mask (tree type, unsigned bits) 1283 { 1284 double_int mask; 1285 1286 gcc_assert (bits <= TYPE_PRECISION (type)); 1287 1288 if (bits == TYPE_PRECISION (type) 1289 && !TYPE_UNSIGNED (type)) 1290 /* Sign extended all-ones mask. */ 1291 mask = double_int_minus_one; 1292 else 1293 mask = double_int_mask (bits); 1294 1295 return build_int_cst_wide (type, mask.low, mask.high); 1296 } 1297 1298 /* Checks that X is integer constant that can be expressed in (unsigned) 1299 HOST_WIDE_INT without loss of precision. */ 1300 1301 bool 1302 cst_and_fits_in_hwi (const_tree x) 1303 { 1304 if (TREE_CODE (x) != INTEGER_CST) 1305 return false; 1306 1307 if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT) 1308 return false; 1309 1310 return (TREE_INT_CST_HIGH (x) == 0 1311 || TREE_INT_CST_HIGH (x) == -1); 1312 } 1313 1314 /* Return a new VECTOR_CST node whose type is TYPE and whose values 1315 are in a list pointed to by VALS. */ 1316 1317 tree 1318 build_vector (tree type, tree vals) 1319 { 1320 tree v = make_node (VECTOR_CST); 1321 int over = 0; 1322 tree link; 1323 unsigned cnt = 0; 1324 1325 TREE_VECTOR_CST_ELTS (v) = vals; 1326 TREE_TYPE (v) = type; 1327 1328 /* Iterate through elements and check for overflow. */ 1329 for (link = vals; link; link = TREE_CHAIN (link)) 1330 { 1331 tree value = TREE_VALUE (link); 1332 cnt++; 1333 1334 /* Don't crash if we get an address constant. */ 1335 if (!CONSTANT_CLASS_P (value)) 1336 continue; 1337 1338 over |= TREE_OVERFLOW (value); 1339 } 1340 1341 gcc_assert (cnt == TYPE_VECTOR_SUBPARTS (type)); 1342 1343 TREE_OVERFLOW (v) = over; 1344 return v; 1345 } 1346 1347 /* Return a new VECTOR_CST node whose type is TYPE and whose values 1348 are extracted from V, a vector of CONSTRUCTOR_ELT. */ 1349 1350 tree 1351 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v) 1352 { 1353 tree list = NULL_TREE; 1354 unsigned HOST_WIDE_INT idx; 1355 tree value; 1356 1357 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) 1358 list = tree_cons (NULL_TREE, value, list); 1359 for (; idx < TYPE_VECTOR_SUBPARTS (type); ++idx) 1360 list = tree_cons (NULL_TREE, 1361 build_zero_cst (TREE_TYPE (type)), list); 1362 return build_vector (type, nreverse (list)); 1363 } 1364 1365 /* Build a vector of type VECTYPE where all the elements are SCs. */ 1366 tree 1367 build_vector_from_val (tree vectype, tree sc) 1368 { 1369 int i, nunits = TYPE_VECTOR_SUBPARTS (vectype); 1370 VEC(constructor_elt, gc) *v = NULL; 1371 1372 if (sc == error_mark_node) 1373 return sc; 1374 1375 /* Verify that the vector type is suitable for SC. Note that there 1376 is some inconsistency in the type-system with respect to restrict 1377 qualifications of pointers. Vector types always have a main-variant 1378 element type and the qualification is applied to the vector-type. 1379 So TREE_TYPE (vector-type) does not return a properly qualified 1380 vector element-type. */ 1381 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)), 1382 TREE_TYPE (vectype))); 1383 1384 v = VEC_alloc (constructor_elt, gc, nunits); 1385 for (i = 0; i < nunits; ++i) 1386 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc); 1387 1388 if (CONSTANT_CLASS_P (sc)) 1389 return build_vector_from_ctor (vectype, v); 1390 else 1391 return build_constructor (vectype, v); 1392 } 1393 1394 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values 1395 are in the VEC pointed to by VALS. */ 1396 tree 1397 build_constructor (tree type, VEC(constructor_elt,gc) *vals) 1398 { 1399 tree c = make_node (CONSTRUCTOR); 1400 unsigned int i; 1401 constructor_elt *elt; 1402 bool constant_p = true; 1403 1404 TREE_TYPE (c) = type; 1405 CONSTRUCTOR_ELTS (c) = vals; 1406 1407 FOR_EACH_VEC_ELT (constructor_elt, vals, i, elt) 1408 if (!TREE_CONSTANT (elt->value)) 1409 { 1410 constant_p = false; 1411 break; 1412 } 1413 1414 TREE_CONSTANT (c) = constant_p; 1415 1416 return c; 1417 } 1418 1419 /* Build a CONSTRUCTOR node made of a single initializer, with the specified 1420 INDEX and VALUE. */ 1421 tree 1422 build_constructor_single (tree type, tree index, tree value) 1423 { 1424 VEC(constructor_elt,gc) *v; 1425 constructor_elt *elt; 1426 1427 v = VEC_alloc (constructor_elt, gc, 1); 1428 elt = VEC_quick_push (constructor_elt, v, NULL); 1429 elt->index = index; 1430 elt->value = value; 1431 1432 return build_constructor (type, v); 1433 } 1434 1435 1436 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values 1437 are in a list pointed to by VALS. */ 1438 tree 1439 build_constructor_from_list (tree type, tree vals) 1440 { 1441 tree t; 1442 VEC(constructor_elt,gc) *v = NULL; 1443 1444 if (vals) 1445 { 1446 v = VEC_alloc (constructor_elt, gc, list_length (vals)); 1447 for (t = vals; t; t = TREE_CHAIN (t)) 1448 CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t)); 1449 } 1450 1451 return build_constructor (type, v); 1452 } 1453 1454 /* Return a new FIXED_CST node whose type is TYPE and value is F. */ 1455 1456 tree 1457 build_fixed (tree type, FIXED_VALUE_TYPE f) 1458 { 1459 tree v; 1460 FIXED_VALUE_TYPE *fp; 1461 1462 v = make_node (FIXED_CST); 1463 fp = ggc_alloc_fixed_value (); 1464 memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE)); 1465 1466 TREE_TYPE (v) = type; 1467 TREE_FIXED_CST_PTR (v) = fp; 1468 return v; 1469 } 1470 1471 /* Return a new REAL_CST node whose type is TYPE and value is D. */ 1472 1473 tree 1474 build_real (tree type, REAL_VALUE_TYPE d) 1475 { 1476 tree v; 1477 REAL_VALUE_TYPE *dp; 1478 int overflow = 0; 1479 1480 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE. 1481 Consider doing it via real_convert now. */ 1482 1483 v = make_node (REAL_CST); 1484 dp = ggc_alloc_real_value (); 1485 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE)); 1486 1487 TREE_TYPE (v) = type; 1488 TREE_REAL_CST_PTR (v) = dp; 1489 TREE_OVERFLOW (v) = overflow; 1490 return v; 1491 } 1492 1493 /* Return a new REAL_CST node whose type is TYPE 1494 and whose value is the integer value of the INTEGER_CST node I. */ 1495 1496 REAL_VALUE_TYPE 1497 real_value_from_int_cst (const_tree type, const_tree i) 1498 { 1499 REAL_VALUE_TYPE d; 1500 1501 /* Clear all bits of the real value type so that we can later do 1502 bitwise comparisons to see if two values are the same. */ 1503 memset (&d, 0, sizeof d); 1504 1505 real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, 1506 TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i), 1507 TYPE_UNSIGNED (TREE_TYPE (i))); 1508 return d; 1509 } 1510 1511 /* Given a tree representing an integer constant I, return a tree 1512 representing the same value as a floating-point constant of type TYPE. */ 1513 1514 tree 1515 build_real_from_int_cst (tree type, const_tree i) 1516 { 1517 tree v; 1518 int overflow = TREE_OVERFLOW (i); 1519 1520 v = build_real (type, real_value_from_int_cst (type, i)); 1521 1522 TREE_OVERFLOW (v) |= overflow; 1523 return v; 1524 } 1525 1526 /* Return a newly constructed STRING_CST node whose value is 1527 the LEN characters at STR. 1528 Note that for a C string literal, LEN should include the trailing NUL. 1529 The TREE_TYPE is not initialized. */ 1530 1531 tree 1532 build_string (int len, const char *str) 1533 { 1534 tree s; 1535 size_t length; 1536 1537 /* Do not waste bytes provided by padding of struct tree_string. */ 1538 length = len + offsetof (struct tree_string, str) + 1; 1539 1540 record_node_allocation_statistics (STRING_CST, length); 1541 1542 s = ggc_alloc_tree_node (length); 1543 1544 memset (s, 0, sizeof (struct tree_typed)); 1545 TREE_SET_CODE (s, STRING_CST); 1546 TREE_CONSTANT (s) = 1; 1547 TREE_STRING_LENGTH (s) = len; 1548 memcpy (s->string.str, str, len); 1549 s->string.str[len] = '\0'; 1550 1551 return s; 1552 } 1553 1554 /* Return a newly constructed COMPLEX_CST node whose value is 1555 specified by the real and imaginary parts REAL and IMAG. 1556 Both REAL and IMAG should be constant nodes. TYPE, if specified, 1557 will be the type of the COMPLEX_CST; otherwise a new type will be made. */ 1558 1559 tree 1560 build_complex (tree type, tree real, tree imag) 1561 { 1562 tree t = make_node (COMPLEX_CST); 1563 1564 TREE_REALPART (t) = real; 1565 TREE_IMAGPART (t) = imag; 1566 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real)); 1567 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag); 1568 return t; 1569 } 1570 1571 /* Return a constant of arithmetic type TYPE which is the 1572 multiplicative identity of the set TYPE. */ 1573 1574 tree 1575 build_one_cst (tree type) 1576 { 1577 switch (TREE_CODE (type)) 1578 { 1579 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: 1580 case POINTER_TYPE: case REFERENCE_TYPE: 1581 case OFFSET_TYPE: 1582 return build_int_cst (type, 1); 1583 1584 case REAL_TYPE: 1585 return build_real (type, dconst1); 1586 1587 case FIXED_POINT_TYPE: 1588 /* We can only generate 1 for accum types. */ 1589 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type))); 1590 return build_fixed (type, FCONST1(TYPE_MODE (type))); 1591 1592 case VECTOR_TYPE: 1593 { 1594 tree scalar = build_one_cst (TREE_TYPE (type)); 1595 1596 return build_vector_from_val (type, scalar); 1597 } 1598 1599 case COMPLEX_TYPE: 1600 return build_complex (type, 1601 build_one_cst (TREE_TYPE (type)), 1602 build_zero_cst (TREE_TYPE (type))); 1603 1604 default: 1605 gcc_unreachable (); 1606 } 1607 } 1608 1609 /* Build 0 constant of type TYPE. This is used by constructor folding 1610 and thus the constant should be represented in memory by 1611 zero(es). */ 1612 1613 tree 1614 build_zero_cst (tree type) 1615 { 1616 switch (TREE_CODE (type)) 1617 { 1618 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: 1619 case POINTER_TYPE: case REFERENCE_TYPE: 1620 case OFFSET_TYPE: case NULLPTR_TYPE: 1621 return build_int_cst (type, 0); 1622 1623 case REAL_TYPE: 1624 return build_real (type, dconst0); 1625 1626 case FIXED_POINT_TYPE: 1627 return build_fixed (type, FCONST0 (TYPE_MODE (type))); 1628 1629 case VECTOR_TYPE: 1630 { 1631 tree scalar = build_zero_cst (TREE_TYPE (type)); 1632 1633 return build_vector_from_val (type, scalar); 1634 } 1635 1636 case COMPLEX_TYPE: 1637 { 1638 tree zero = build_zero_cst (TREE_TYPE (type)); 1639 1640 return build_complex (type, zero, zero); 1641 } 1642 1643 default: 1644 if (!AGGREGATE_TYPE_P (type)) 1645 return fold_convert (type, integer_zero_node); 1646 return build_constructor (type, NULL); 1647 } 1648 } 1649 1650 1651 /* Build a BINFO with LEN language slots. */ 1652 1653 tree 1654 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL) 1655 { 1656 tree t; 1657 size_t length = (offsetof (struct tree_binfo, base_binfos) 1658 + VEC_embedded_size (tree, base_binfos)); 1659 1660 record_node_allocation_statistics (TREE_BINFO, length); 1661 1662 t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT); 1663 1664 memset (t, 0, offsetof (struct tree_binfo, base_binfos)); 1665 1666 TREE_SET_CODE (t, TREE_BINFO); 1667 1668 VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos); 1669 1670 return t; 1671 } 1672 1673 /* Create a CASE_LABEL_EXPR tree node and return it. */ 1674 1675 tree 1676 build_case_label (tree low_value, tree high_value, tree label_decl) 1677 { 1678 tree t = make_node (CASE_LABEL_EXPR); 1679 1680 TREE_TYPE (t) = void_type_node; 1681 SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl)); 1682 1683 CASE_LOW (t) = low_value; 1684 CASE_HIGH (t) = high_value; 1685 CASE_LABEL (t) = label_decl; 1686 CASE_CHAIN (t) = NULL_TREE; 1687 1688 return t; 1689 } 1690 1691 /* Build a newly constructed TREE_VEC node of length LEN. */ 1692 1693 tree 1694 make_tree_vec_stat (int len MEM_STAT_DECL) 1695 { 1696 tree t; 1697 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec); 1698 1699 record_node_allocation_statistics (TREE_VEC, length); 1700 1701 t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT); 1702 1703 TREE_SET_CODE (t, TREE_VEC); 1704 TREE_VEC_LENGTH (t) = len; 1705 1706 return t; 1707 } 1708 1709 /* Return 1 if EXPR is the integer constant zero or a complex constant 1710 of zero. */ 1711 1712 int 1713 integer_zerop (const_tree expr) 1714 { 1715 STRIP_NOPS (expr); 1716 1717 return ((TREE_CODE (expr) == INTEGER_CST 1718 && TREE_INT_CST_LOW (expr) == 0 1719 && TREE_INT_CST_HIGH (expr) == 0) 1720 || (TREE_CODE (expr) == COMPLEX_CST 1721 && integer_zerop (TREE_REALPART (expr)) 1722 && integer_zerop (TREE_IMAGPART (expr)))); 1723 } 1724 1725 /* Return 1 if EXPR is the integer constant one or the corresponding 1726 complex constant. */ 1727 1728 int 1729 integer_onep (const_tree expr) 1730 { 1731 STRIP_NOPS (expr); 1732 1733 return ((TREE_CODE (expr) == INTEGER_CST 1734 && TREE_INT_CST_LOW (expr) == 1 1735 && TREE_INT_CST_HIGH (expr) == 0) 1736 || (TREE_CODE (expr) == COMPLEX_CST 1737 && integer_onep (TREE_REALPART (expr)) 1738 && integer_zerop (TREE_IMAGPART (expr)))); 1739 } 1740 1741 /* Return 1 if EXPR is an integer containing all 1's in as much precision as 1742 it contains. Likewise for the corresponding complex constant. */ 1743 1744 int 1745 integer_all_onesp (const_tree expr) 1746 { 1747 int prec; 1748 int uns; 1749 1750 STRIP_NOPS (expr); 1751 1752 if (TREE_CODE (expr) == COMPLEX_CST 1753 && integer_all_onesp (TREE_REALPART (expr)) 1754 && integer_zerop (TREE_IMAGPART (expr))) 1755 return 1; 1756 1757 else if (TREE_CODE (expr) != INTEGER_CST) 1758 return 0; 1759 1760 uns = TYPE_UNSIGNED (TREE_TYPE (expr)); 1761 if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0 1762 && TREE_INT_CST_HIGH (expr) == -1) 1763 return 1; 1764 if (!uns) 1765 return 0; 1766 1767 prec = TYPE_PRECISION (TREE_TYPE (expr)); 1768 if (prec >= HOST_BITS_PER_WIDE_INT) 1769 { 1770 HOST_WIDE_INT high_value; 1771 int shift_amount; 1772 1773 shift_amount = prec - HOST_BITS_PER_WIDE_INT; 1774 1775 /* Can not handle precisions greater than twice the host int size. */ 1776 gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT); 1777 if (shift_amount == HOST_BITS_PER_WIDE_INT) 1778 /* Shifting by the host word size is undefined according to the ANSI 1779 standard, so we must handle this as a special case. */ 1780 high_value = -1; 1781 else 1782 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1; 1783 1784 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0 1785 && TREE_INT_CST_HIGH (expr) == high_value); 1786 } 1787 else 1788 return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1; 1789 } 1790 1791 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only 1792 one bit on). */ 1793 1794 int 1795 integer_pow2p (const_tree expr) 1796 { 1797 int prec; 1798 HOST_WIDE_INT high, low; 1799 1800 STRIP_NOPS (expr); 1801 1802 if (TREE_CODE (expr) == COMPLEX_CST 1803 && integer_pow2p (TREE_REALPART (expr)) 1804 && integer_zerop (TREE_IMAGPART (expr))) 1805 return 1; 1806 1807 if (TREE_CODE (expr) != INTEGER_CST) 1808 return 0; 1809 1810 prec = TYPE_PRECISION (TREE_TYPE (expr)); 1811 high = TREE_INT_CST_HIGH (expr); 1812 low = TREE_INT_CST_LOW (expr); 1813 1814 /* First clear all bits that are beyond the type's precision in case 1815 we've been sign extended. */ 1816 1817 if (prec == 2 * HOST_BITS_PER_WIDE_INT) 1818 ; 1819 else if (prec > HOST_BITS_PER_WIDE_INT) 1820 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); 1821 else 1822 { 1823 high = 0; 1824 if (prec < HOST_BITS_PER_WIDE_INT) 1825 low &= ~((HOST_WIDE_INT) (-1) << prec); 1826 } 1827 1828 if (high == 0 && low == 0) 1829 return 0; 1830 1831 return ((high == 0 && (low & (low - 1)) == 0) 1832 || (low == 0 && (high & (high - 1)) == 0)); 1833 } 1834 1835 /* Return 1 if EXPR is an integer constant other than zero or a 1836 complex constant other than zero. */ 1837 1838 int 1839 integer_nonzerop (const_tree expr) 1840 { 1841 STRIP_NOPS (expr); 1842 1843 return ((TREE_CODE (expr) == INTEGER_CST 1844 && (TREE_INT_CST_LOW (expr) != 0 1845 || TREE_INT_CST_HIGH (expr) != 0)) 1846 || (TREE_CODE (expr) == COMPLEX_CST 1847 && (integer_nonzerop (TREE_REALPART (expr)) 1848 || integer_nonzerop (TREE_IMAGPART (expr))))); 1849 } 1850 1851 /* Return 1 if EXPR is the fixed-point constant zero. */ 1852 1853 int 1854 fixed_zerop (const_tree expr) 1855 { 1856 return (TREE_CODE (expr) == FIXED_CST 1857 && double_int_zero_p (TREE_FIXED_CST (expr).data)); 1858 } 1859 1860 /* Return the power of two represented by a tree node known to be a 1861 power of two. */ 1862 1863 int 1864 tree_log2 (const_tree expr) 1865 { 1866 int prec; 1867 HOST_WIDE_INT high, low; 1868 1869 STRIP_NOPS (expr); 1870 1871 if (TREE_CODE (expr) == COMPLEX_CST) 1872 return tree_log2 (TREE_REALPART (expr)); 1873 1874 prec = TYPE_PRECISION (TREE_TYPE (expr)); 1875 high = TREE_INT_CST_HIGH (expr); 1876 low = TREE_INT_CST_LOW (expr); 1877 1878 /* First clear all bits that are beyond the type's precision in case 1879 we've been sign extended. */ 1880 1881 if (prec == 2 * HOST_BITS_PER_WIDE_INT) 1882 ; 1883 else if (prec > HOST_BITS_PER_WIDE_INT) 1884 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); 1885 else 1886 { 1887 high = 0; 1888 if (prec < HOST_BITS_PER_WIDE_INT) 1889 low &= ~((HOST_WIDE_INT) (-1) << prec); 1890 } 1891 1892 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high) 1893 : exact_log2 (low)); 1894 } 1895 1896 /* Similar, but return the largest integer Y such that 2 ** Y is less 1897 than or equal to EXPR. */ 1898 1899 int 1900 tree_floor_log2 (const_tree expr) 1901 { 1902 int prec; 1903 HOST_WIDE_INT high, low; 1904 1905 STRIP_NOPS (expr); 1906 1907 if (TREE_CODE (expr) == COMPLEX_CST) 1908 return tree_log2 (TREE_REALPART (expr)); 1909 1910 prec = TYPE_PRECISION (TREE_TYPE (expr)); 1911 high = TREE_INT_CST_HIGH (expr); 1912 low = TREE_INT_CST_LOW (expr); 1913 1914 /* First clear all bits that are beyond the type's precision in case 1915 we've been sign extended. Ignore if type's precision hasn't been set 1916 since what we are doing is setting it. */ 1917 1918 if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0) 1919 ; 1920 else if (prec > HOST_BITS_PER_WIDE_INT) 1921 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); 1922 else 1923 { 1924 high = 0; 1925 if (prec < HOST_BITS_PER_WIDE_INT) 1926 low &= ~((HOST_WIDE_INT) (-1) << prec); 1927 } 1928 1929 return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high) 1930 : floor_log2 (low)); 1931 } 1932 1933 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for 1934 decimal float constants, so don't return 1 for them. */ 1935 1936 int 1937 real_zerop (const_tree expr) 1938 { 1939 STRIP_NOPS (expr); 1940 1941 return ((TREE_CODE (expr) == REAL_CST 1942 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0) 1943 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) 1944 || (TREE_CODE (expr) == COMPLEX_CST 1945 && real_zerop (TREE_REALPART (expr)) 1946 && real_zerop (TREE_IMAGPART (expr)))); 1947 } 1948 1949 /* Return 1 if EXPR is the real constant one in real or complex form. 1950 Trailing zeroes matter for decimal float constants, so don't return 1951 1 for them. */ 1952 1953 int 1954 real_onep (const_tree expr) 1955 { 1956 STRIP_NOPS (expr); 1957 1958 return ((TREE_CODE (expr) == REAL_CST 1959 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1) 1960 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) 1961 || (TREE_CODE (expr) == COMPLEX_CST 1962 && real_onep (TREE_REALPART (expr)) 1963 && real_zerop (TREE_IMAGPART (expr)))); 1964 } 1965 1966 /* Return 1 if EXPR is the real constant two. Trailing zeroes matter 1967 for decimal float constants, so don't return 1 for them. */ 1968 1969 int 1970 real_twop (const_tree expr) 1971 { 1972 STRIP_NOPS (expr); 1973 1974 return ((TREE_CODE (expr) == REAL_CST 1975 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2) 1976 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) 1977 || (TREE_CODE (expr) == COMPLEX_CST 1978 && real_twop (TREE_REALPART (expr)) 1979 && real_zerop (TREE_IMAGPART (expr)))); 1980 } 1981 1982 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes 1983 matter for decimal float constants, so don't return 1 for them. */ 1984 1985 int 1986 real_minus_onep (const_tree expr) 1987 { 1988 STRIP_NOPS (expr); 1989 1990 return ((TREE_CODE (expr) == REAL_CST 1991 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1) 1992 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) 1993 || (TREE_CODE (expr) == COMPLEX_CST 1994 && real_minus_onep (TREE_REALPART (expr)) 1995 && real_zerop (TREE_IMAGPART (expr)))); 1996 } 1997 1998 /* Nonzero if EXP is a constant or a cast of a constant. */ 1999 2000 int 2001 really_constant_p (const_tree exp) 2002 { 2003 /* This is not quite the same as STRIP_NOPS. It does more. */ 2004 while (CONVERT_EXPR_P (exp) 2005 || TREE_CODE (exp) == NON_LVALUE_EXPR) 2006 exp = TREE_OPERAND (exp, 0); 2007 return TREE_CONSTANT (exp); 2008 } 2009 2010 /* Return first list element whose TREE_VALUE is ELEM. 2011 Return 0 if ELEM is not in LIST. */ 2012 2013 tree 2014 value_member (tree elem, tree list) 2015 { 2016 while (list) 2017 { 2018 if (elem == TREE_VALUE (list)) 2019 return list; 2020 list = TREE_CHAIN (list); 2021 } 2022 return NULL_TREE; 2023 } 2024 2025 /* Return first list element whose TREE_PURPOSE is ELEM. 2026 Return 0 if ELEM is not in LIST. */ 2027 2028 tree 2029 purpose_member (const_tree elem, tree list) 2030 { 2031 while (list) 2032 { 2033 if (elem == TREE_PURPOSE (list)) 2034 return list; 2035 list = TREE_CHAIN (list); 2036 } 2037 return NULL_TREE; 2038 } 2039 2040 /* Return true if ELEM is in V. */ 2041 2042 bool 2043 vec_member (const_tree elem, VEC(tree,gc) *v) 2044 { 2045 unsigned ix; 2046 tree t; 2047 FOR_EACH_VEC_ELT (tree, v, ix, t) 2048 if (elem == t) 2049 return true; 2050 return false; 2051 } 2052 2053 /* Returns element number IDX (zero-origin) of chain CHAIN, or 2054 NULL_TREE. */ 2055 2056 tree 2057 chain_index (int idx, tree chain) 2058 { 2059 for (; chain && idx > 0; --idx) 2060 chain = TREE_CHAIN (chain); 2061 return chain; 2062 } 2063 2064 /* Return nonzero if ELEM is part of the chain CHAIN. */ 2065 2066 int 2067 chain_member (const_tree elem, const_tree chain) 2068 { 2069 while (chain) 2070 { 2071 if (elem == chain) 2072 return 1; 2073 chain = DECL_CHAIN (chain); 2074 } 2075 2076 return 0; 2077 } 2078 2079 /* Return the length of a chain of nodes chained through TREE_CHAIN. 2080 We expect a null pointer to mark the end of the chain. 2081 This is the Lisp primitive `length'. */ 2082 2083 int 2084 list_length (const_tree t) 2085 { 2086 const_tree p = t; 2087 #ifdef ENABLE_TREE_CHECKING 2088 const_tree q = t; 2089 #endif 2090 int len = 0; 2091 2092 while (p) 2093 { 2094 p = TREE_CHAIN (p); 2095 #ifdef ENABLE_TREE_CHECKING 2096 if (len % 2) 2097 q = TREE_CHAIN (q); 2098 gcc_assert (p != q); 2099 #endif 2100 len++; 2101 } 2102 2103 return len; 2104 } 2105 2106 /* Returns the number of FIELD_DECLs in TYPE. */ 2107 2108 int 2109 fields_length (const_tree type) 2110 { 2111 tree t = TYPE_FIELDS (type); 2112 int count = 0; 2113 2114 for (; t; t = DECL_CHAIN (t)) 2115 if (TREE_CODE (t) == FIELD_DECL) 2116 ++count; 2117 2118 return count; 2119 } 2120 2121 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or 2122 UNION_TYPE TYPE, or NULL_TREE if none. */ 2123 2124 tree 2125 first_field (const_tree type) 2126 { 2127 tree t = TYPE_FIELDS (type); 2128 while (t && TREE_CODE (t) != FIELD_DECL) 2129 t = TREE_CHAIN (t); 2130 return t; 2131 } 2132 2133 /* Concatenate two chains of nodes (chained through TREE_CHAIN) 2134 by modifying the last node in chain 1 to point to chain 2. 2135 This is the Lisp primitive `nconc'. */ 2136 2137 tree 2138 chainon (tree op1, tree op2) 2139 { 2140 tree t1; 2141 2142 if (!op1) 2143 return op2; 2144 if (!op2) 2145 return op1; 2146 2147 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1)) 2148 continue; 2149 TREE_CHAIN (t1) = op2; 2150 2151 #ifdef ENABLE_TREE_CHECKING 2152 { 2153 tree t2; 2154 for (t2 = op2; t2; t2 = TREE_CHAIN (t2)) 2155 gcc_assert (t2 != t1); 2156 } 2157 #endif 2158 2159 return op1; 2160 } 2161 2162 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */ 2163 2164 tree 2165 tree_last (tree chain) 2166 { 2167 tree next; 2168 if (chain) 2169 while ((next = TREE_CHAIN (chain))) 2170 chain = next; 2171 return chain; 2172 } 2173 2174 /* Reverse the order of elements in the chain T, 2175 and return the new head of the chain (old last element). */ 2176 2177 tree 2178 nreverse (tree t) 2179 { 2180 tree prev = 0, decl, next; 2181 for (decl = t; decl; decl = next) 2182 { 2183 /* We shouldn't be using this function to reverse BLOCK chains; we 2184 have blocks_nreverse for that. */ 2185 gcc_checking_assert (TREE_CODE (decl) != BLOCK); 2186 next = TREE_CHAIN (decl); 2187 TREE_CHAIN (decl) = prev; 2188 prev = decl; 2189 } 2190 return prev; 2191 } 2192 2193 /* Return a newly created TREE_LIST node whose 2194 purpose and value fields are PARM and VALUE. */ 2195 2196 tree 2197 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL) 2198 { 2199 tree t = make_node_stat (TREE_LIST PASS_MEM_STAT); 2200 TREE_PURPOSE (t) = parm; 2201 TREE_VALUE (t) = value; 2202 return t; 2203 } 2204 2205 /* Build a chain of TREE_LIST nodes from a vector. */ 2206 2207 tree 2208 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL) 2209 { 2210 tree ret = NULL_TREE; 2211 tree *pp = &ret; 2212 unsigned int i; 2213 tree t; 2214 FOR_EACH_VEC_ELT (tree, vec, i, t) 2215 { 2216 *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT); 2217 pp = &TREE_CHAIN (*pp); 2218 } 2219 return ret; 2220 } 2221 2222 /* Return a newly created TREE_LIST node whose 2223 purpose and value fields are PURPOSE and VALUE 2224 and whose TREE_CHAIN is CHAIN. */ 2225 2226 tree 2227 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL) 2228 { 2229 tree node; 2230 2231 node = ggc_alloc_zone_tree_node_stat (&tree_zone, sizeof (struct tree_list) 2232 PASS_MEM_STAT); 2233 memset (node, 0, sizeof (struct tree_common)); 2234 2235 record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list)); 2236 2237 TREE_SET_CODE (node, TREE_LIST); 2238 TREE_CHAIN (node) = chain; 2239 TREE_PURPOSE (node) = purpose; 2240 TREE_VALUE (node) = value; 2241 return node; 2242 } 2243 2244 /* Return the values of the elements of a CONSTRUCTOR as a vector of 2245 trees. */ 2246 2247 VEC(tree,gc) * 2248 ctor_to_vec (tree ctor) 2249 { 2250 VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor)); 2251 unsigned int ix; 2252 tree val; 2253 2254 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val) 2255 VEC_quick_push (tree, vec, val); 2256 2257 return vec; 2258 } 2259 2260 /* Return the size nominally occupied by an object of type TYPE 2261 when it resides in memory. The value is measured in units of bytes, 2262 and its data type is that normally used for type sizes 2263 (which is the first type created by make_signed_type or 2264 make_unsigned_type). */ 2265 2266 tree 2267 size_in_bytes (const_tree type) 2268 { 2269 tree t; 2270 2271 if (type == error_mark_node) 2272 return integer_zero_node; 2273 2274 type = TYPE_MAIN_VARIANT (type); 2275 t = TYPE_SIZE_UNIT (type); 2276 2277 if (t == 0) 2278 { 2279 lang_hooks.types.incomplete_type_error (NULL_TREE, type); 2280 return size_zero_node; 2281 } 2282 2283 return t; 2284 } 2285 2286 /* Return the size of TYPE (in bytes) as a wide integer 2287 or return -1 if the size can vary or is larger than an integer. */ 2288 2289 HOST_WIDE_INT 2290 int_size_in_bytes (const_tree type) 2291 { 2292 tree t; 2293 2294 if (type == error_mark_node) 2295 return 0; 2296 2297 type = TYPE_MAIN_VARIANT (type); 2298 t = TYPE_SIZE_UNIT (type); 2299 if (t == 0 2300 || TREE_CODE (t) != INTEGER_CST 2301 || TREE_INT_CST_HIGH (t) != 0 2302 /* If the result would appear negative, it's too big to represent. */ 2303 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0) 2304 return -1; 2305 2306 return TREE_INT_CST_LOW (t); 2307 } 2308 2309 /* Return the maximum size of TYPE (in bytes) as a wide integer 2310 or return -1 if the size can vary or is larger than an integer. */ 2311 2312 HOST_WIDE_INT 2313 max_int_size_in_bytes (const_tree type) 2314 { 2315 HOST_WIDE_INT size = -1; 2316 tree size_tree; 2317 2318 /* If this is an array type, check for a possible MAX_SIZE attached. */ 2319 2320 if (TREE_CODE (type) == ARRAY_TYPE) 2321 { 2322 size_tree = TYPE_ARRAY_MAX_SIZE (type); 2323 2324 if (size_tree && host_integerp (size_tree, 1)) 2325 size = tree_low_cst (size_tree, 1); 2326 } 2327 2328 /* If we still haven't been able to get a size, see if the language 2329 can compute a maximum size. */ 2330 2331 if (size == -1) 2332 { 2333 size_tree = lang_hooks.types.max_size (type); 2334 2335 if (size_tree && host_integerp (size_tree, 1)) 2336 size = tree_low_cst (size_tree, 1); 2337 } 2338 2339 return size; 2340 } 2341 2342 /* Returns a tree for the size of EXP in bytes. */ 2343 2344 tree 2345 tree_expr_size (const_tree exp) 2346 { 2347 if (DECL_P (exp) 2348 && DECL_SIZE_UNIT (exp) != 0) 2349 return DECL_SIZE_UNIT (exp); 2350 else 2351 return size_in_bytes (TREE_TYPE (exp)); 2352 } 2353 2354 /* Return the bit position of FIELD, in bits from the start of the record. 2355 This is a tree of type bitsizetype. */ 2356 2357 tree 2358 bit_position (const_tree field) 2359 { 2360 return bit_from_pos (DECL_FIELD_OFFSET (field), 2361 DECL_FIELD_BIT_OFFSET (field)); 2362 } 2363 2364 /* Likewise, but return as an integer. It must be representable in 2365 that way (since it could be a signed value, we don't have the 2366 option of returning -1 like int_size_in_byte can. */ 2367 2368 HOST_WIDE_INT 2369 int_bit_position (const_tree field) 2370 { 2371 return tree_low_cst (bit_position (field), 0); 2372 } 2373 2374 /* Return the byte position of FIELD, in bytes from the start of the record. 2375 This is a tree of type sizetype. */ 2376 2377 tree 2378 byte_position (const_tree field) 2379 { 2380 return byte_from_pos (DECL_FIELD_OFFSET (field), 2381 DECL_FIELD_BIT_OFFSET (field)); 2382 } 2383 2384 /* Likewise, but return as an integer. It must be representable in 2385 that way (since it could be a signed value, we don't have the 2386 option of returning -1 like int_size_in_byte can. */ 2387 2388 HOST_WIDE_INT 2389 int_byte_position (const_tree field) 2390 { 2391 return tree_low_cst (byte_position (field), 0); 2392 } 2393 2394 /* Return the strictest alignment, in bits, that T is known to have. */ 2395 2396 unsigned int 2397 expr_align (const_tree t) 2398 { 2399 unsigned int align0, align1; 2400 2401 switch (TREE_CODE (t)) 2402 { 2403 CASE_CONVERT: case NON_LVALUE_EXPR: 2404 /* If we have conversions, we know that the alignment of the 2405 object must meet each of the alignments of the types. */ 2406 align0 = expr_align (TREE_OPERAND (t, 0)); 2407 align1 = TYPE_ALIGN (TREE_TYPE (t)); 2408 return MAX (align0, align1); 2409 2410 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR: 2411 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR: 2412 case CLEANUP_POINT_EXPR: 2413 /* These don't change the alignment of an object. */ 2414 return expr_align (TREE_OPERAND (t, 0)); 2415 2416 case COND_EXPR: 2417 /* The best we can do is say that the alignment is the least aligned 2418 of the two arms. */ 2419 align0 = expr_align (TREE_OPERAND (t, 1)); 2420 align1 = expr_align (TREE_OPERAND (t, 2)); 2421 return MIN (align0, align1); 2422 2423 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set 2424 meaningfully, it's always 1. */ 2425 case LABEL_DECL: case CONST_DECL: 2426 case VAR_DECL: case PARM_DECL: case RESULT_DECL: 2427 case FUNCTION_DECL: 2428 gcc_assert (DECL_ALIGN (t) != 0); 2429 return DECL_ALIGN (t); 2430 2431 default: 2432 break; 2433 } 2434 2435 /* Otherwise take the alignment from that of the type. */ 2436 return TYPE_ALIGN (TREE_TYPE (t)); 2437 } 2438 2439 /* Return, as a tree node, the number of elements for TYPE (which is an 2440 ARRAY_TYPE) minus one. This counts only elements of the top array. */ 2441 2442 tree 2443 array_type_nelts (const_tree type) 2444 { 2445 tree index_type, min, max; 2446 2447 /* If they did it with unspecified bounds, then we should have already 2448 given an error about it before we got here. */ 2449 if (! TYPE_DOMAIN (type)) 2450 return error_mark_node; 2451 2452 index_type = TYPE_DOMAIN (type); 2453 min = TYPE_MIN_VALUE (index_type); 2454 max = TYPE_MAX_VALUE (index_type); 2455 2456 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */ 2457 if (!max) 2458 return error_mark_node; 2459 2460 return (integer_zerop (min) 2461 ? max 2462 : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min)); 2463 } 2464 2465 /* If arg is static -- a reference to an object in static storage -- then 2466 return the object. This is not the same as the C meaning of `static'. 2467 If arg isn't static, return NULL. */ 2468 2469 tree 2470 staticp (tree arg) 2471 { 2472 switch (TREE_CODE (arg)) 2473 { 2474 case FUNCTION_DECL: 2475 /* Nested functions are static, even though taking their address will 2476 involve a trampoline as we unnest the nested function and create 2477 the trampoline on the tree level. */ 2478 return arg; 2479 2480 case VAR_DECL: 2481 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg)) 2482 && ! DECL_THREAD_LOCAL_P (arg) 2483 && ! DECL_DLLIMPORT_P (arg) 2484 ? arg : NULL); 2485 2486 case CONST_DECL: 2487 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg)) 2488 ? arg : NULL); 2489 2490 case CONSTRUCTOR: 2491 return TREE_STATIC (arg) ? arg : NULL; 2492 2493 case LABEL_DECL: 2494 case STRING_CST: 2495 return arg; 2496 2497 case COMPONENT_REF: 2498 /* If the thing being referenced is not a field, then it is 2499 something language specific. */ 2500 gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL); 2501 2502 /* If we are referencing a bitfield, we can't evaluate an 2503 ADDR_EXPR at compile time and so it isn't a constant. */ 2504 if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1))) 2505 return NULL; 2506 2507 return staticp (TREE_OPERAND (arg, 0)); 2508 2509 case BIT_FIELD_REF: 2510 return NULL; 2511 2512 case INDIRECT_REF: 2513 return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL; 2514 2515 case ARRAY_REF: 2516 case ARRAY_RANGE_REF: 2517 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST 2518 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST) 2519 return staticp (TREE_OPERAND (arg, 0)); 2520 else 2521 return NULL; 2522 2523 case COMPOUND_LITERAL_EXPR: 2524 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL; 2525 2526 default: 2527 return NULL; 2528 } 2529 } 2530 2531 2532 2533 2534 /* Return whether OP is a DECL whose address is function-invariant. */ 2535 2536 bool 2537 decl_address_invariant_p (const_tree op) 2538 { 2539 /* The conditions below are slightly less strict than the one in 2540 staticp. */ 2541 2542 switch (TREE_CODE (op)) 2543 { 2544 case PARM_DECL: 2545 case RESULT_DECL: 2546 case LABEL_DECL: 2547 case FUNCTION_DECL: 2548 return true; 2549 2550 case VAR_DECL: 2551 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)) 2552 || DECL_THREAD_LOCAL_P (op) 2553 || DECL_CONTEXT (op) == current_function_decl 2554 || decl_function_context (op) == current_function_decl) 2555 return true; 2556 break; 2557 2558 case CONST_DECL: 2559 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)) 2560 || decl_function_context (op) == current_function_decl) 2561 return true; 2562 break; 2563 2564 default: 2565 break; 2566 } 2567 2568 return false; 2569 } 2570 2571 /* Return whether OP is a DECL whose address is interprocedural-invariant. */ 2572 2573 bool 2574 decl_address_ip_invariant_p (const_tree op) 2575 { 2576 /* The conditions below are slightly less strict than the one in 2577 staticp. */ 2578 2579 switch (TREE_CODE (op)) 2580 { 2581 case LABEL_DECL: 2582 case FUNCTION_DECL: 2583 case STRING_CST: 2584 return true; 2585 2586 case VAR_DECL: 2587 if (((TREE_STATIC (op) || DECL_EXTERNAL (op)) 2588 && !DECL_DLLIMPORT_P (op)) 2589 || DECL_THREAD_LOCAL_P (op)) 2590 return true; 2591 break; 2592 2593 case CONST_DECL: 2594 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))) 2595 return true; 2596 break; 2597 2598 default: 2599 break; 2600 } 2601 2602 return false; 2603 } 2604 2605 2606 /* Return true if T is function-invariant (internal function, does 2607 not handle arithmetic; that's handled in skip_simple_arithmetic and 2608 tree_invariant_p). */ 2609 2610 static bool tree_invariant_p (tree t); 2611 2612 static bool 2613 tree_invariant_p_1 (tree t) 2614 { 2615 tree op; 2616 2617 if (TREE_CONSTANT (t) 2618 || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t))) 2619 return true; 2620 2621 switch (TREE_CODE (t)) 2622 { 2623 case SAVE_EXPR: 2624 return true; 2625 2626 case ADDR_EXPR: 2627 op = TREE_OPERAND (t, 0); 2628 while (handled_component_p (op)) 2629 { 2630 switch (TREE_CODE (op)) 2631 { 2632 case ARRAY_REF: 2633 case ARRAY_RANGE_REF: 2634 if (!tree_invariant_p (TREE_OPERAND (op, 1)) 2635 || TREE_OPERAND (op, 2) != NULL_TREE 2636 || TREE_OPERAND (op, 3) != NULL_TREE) 2637 return false; 2638 break; 2639 2640 case COMPONENT_REF: 2641 if (TREE_OPERAND (op, 2) != NULL_TREE) 2642 return false; 2643 break; 2644 2645 default:; 2646 } 2647 op = TREE_OPERAND (op, 0); 2648 } 2649 2650 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op); 2651 2652 default: 2653 break; 2654 } 2655 2656 return false; 2657 } 2658 2659 /* Return true if T is function-invariant. */ 2660 2661 static bool 2662 tree_invariant_p (tree t) 2663 { 2664 tree inner = skip_simple_arithmetic (t); 2665 return tree_invariant_p_1 (inner); 2666 } 2667 2668 /* Wrap a SAVE_EXPR around EXPR, if appropriate. 2669 Do this to any expression which may be used in more than one place, 2670 but must be evaluated only once. 2671 2672 Normally, expand_expr would reevaluate the expression each time. 2673 Calling save_expr produces something that is evaluated and recorded 2674 the first time expand_expr is called on it. Subsequent calls to 2675 expand_expr just reuse the recorded value. 2676 2677 The call to expand_expr that generates code that actually computes 2678 the value is the first call *at compile time*. Subsequent calls 2679 *at compile time* generate code to use the saved value. 2680 This produces correct result provided that *at run time* control 2681 always flows through the insns made by the first expand_expr 2682 before reaching the other places where the save_expr was evaluated. 2683 You, the caller of save_expr, must make sure this is so. 2684 2685 Constants, and certain read-only nodes, are returned with no 2686 SAVE_EXPR because that is safe. Expressions containing placeholders 2687 are not touched; see tree.def for an explanation of what these 2688 are used for. */ 2689 2690 tree 2691 save_expr (tree expr) 2692 { 2693 tree t = fold (expr); 2694 tree inner; 2695 2696 /* If the tree evaluates to a constant, then we don't want to hide that 2697 fact (i.e. this allows further folding, and direct checks for constants). 2698 However, a read-only object that has side effects cannot be bypassed. 2699 Since it is no problem to reevaluate literals, we just return the 2700 literal node. */ 2701 inner = skip_simple_arithmetic (t); 2702 if (TREE_CODE (inner) == ERROR_MARK) 2703 return inner; 2704 2705 if (tree_invariant_p_1 (inner)) 2706 return t; 2707 2708 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since 2709 it means that the size or offset of some field of an object depends on 2710 the value within another field. 2711 2712 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR 2713 and some variable since it would then need to be both evaluated once and 2714 evaluated more than once. Front-ends must assure this case cannot 2715 happen by surrounding any such subexpressions in their own SAVE_EXPR 2716 and forcing evaluation at the proper time. */ 2717 if (contains_placeholder_p (inner)) 2718 return t; 2719 2720 t = build1 (SAVE_EXPR, TREE_TYPE (expr), t); 2721 SET_EXPR_LOCATION (t, EXPR_LOCATION (expr)); 2722 2723 /* This expression might be placed ahead of a jump to ensure that the 2724 value was computed on both sides of the jump. So make sure it isn't 2725 eliminated as dead. */ 2726 TREE_SIDE_EFFECTS (t) = 1; 2727 return t; 2728 } 2729 2730 /* Look inside EXPR and into any simple arithmetic operations. Return 2731 the innermost non-arithmetic node. */ 2732 2733 tree 2734 skip_simple_arithmetic (tree expr) 2735 { 2736 tree inner; 2737 2738 /* We don't care about whether this can be used as an lvalue in this 2739 context. */ 2740 while (TREE_CODE (expr) == NON_LVALUE_EXPR) 2741 expr = TREE_OPERAND (expr, 0); 2742 2743 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and 2744 a constant, it will be more efficient to not make another SAVE_EXPR since 2745 it will allow better simplification and GCSE will be able to merge the 2746 computations if they actually occur. */ 2747 inner = expr; 2748 while (1) 2749 { 2750 if (UNARY_CLASS_P (inner)) 2751 inner = TREE_OPERAND (inner, 0); 2752 else if (BINARY_CLASS_P (inner)) 2753 { 2754 if (tree_invariant_p (TREE_OPERAND (inner, 1))) 2755 inner = TREE_OPERAND (inner, 0); 2756 else if (tree_invariant_p (TREE_OPERAND (inner, 0))) 2757 inner = TREE_OPERAND (inner, 1); 2758 else 2759 break; 2760 } 2761 else 2762 break; 2763 } 2764 2765 return inner; 2766 } 2767 2768 2769 /* Return which tree structure is used by T. */ 2770 2771 enum tree_node_structure_enum 2772 tree_node_structure (const_tree t) 2773 { 2774 const enum tree_code code = TREE_CODE (t); 2775 return tree_node_structure_for_code (code); 2776 } 2777 2778 /* Set various status flags when building a CALL_EXPR object T. */ 2779 2780 static void 2781 process_call_operands (tree t) 2782 { 2783 bool side_effects = TREE_SIDE_EFFECTS (t); 2784 bool read_only = false; 2785 int i = call_expr_flags (t); 2786 2787 /* Calls have side-effects, except those to const or pure functions. */ 2788 if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE))) 2789 side_effects = true; 2790 /* Propagate TREE_READONLY of arguments for const functions. */ 2791 if (i & ECF_CONST) 2792 read_only = true; 2793 2794 if (!side_effects || read_only) 2795 for (i = 1; i < TREE_OPERAND_LENGTH (t); i++) 2796 { 2797 tree op = TREE_OPERAND (t, i); 2798 if (op && TREE_SIDE_EFFECTS (op)) 2799 side_effects = true; 2800 if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op)) 2801 read_only = false; 2802 } 2803 2804 TREE_SIDE_EFFECTS (t) = side_effects; 2805 TREE_READONLY (t) = read_only; 2806 } 2807 2808 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a 2809 size or offset that depends on a field within a record. */ 2810 2811 bool 2812 contains_placeholder_p (const_tree exp) 2813 { 2814 enum tree_code code; 2815 2816 if (!exp) 2817 return 0; 2818 2819 code = TREE_CODE (exp); 2820 if (code == PLACEHOLDER_EXPR) 2821 return 1; 2822 2823 switch (TREE_CODE_CLASS (code)) 2824 { 2825 case tcc_reference: 2826 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit 2827 position computations since they will be converted into a 2828 WITH_RECORD_EXPR involving the reference, which will assume 2829 here will be valid. */ 2830 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)); 2831 2832 case tcc_exceptional: 2833 if (code == TREE_LIST) 2834 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp)) 2835 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp))); 2836 break; 2837 2838 case tcc_unary: 2839 case tcc_binary: 2840 case tcc_comparison: 2841 case tcc_expression: 2842 switch (code) 2843 { 2844 case COMPOUND_EXPR: 2845 /* Ignoring the first operand isn't quite right, but works best. */ 2846 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)); 2847 2848 case COND_EXPR: 2849 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)) 2850 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)) 2851 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2))); 2852 2853 case SAVE_EXPR: 2854 /* The save_expr function never wraps anything containing 2855 a PLACEHOLDER_EXPR. */ 2856 return 0; 2857 2858 default: 2859 break; 2860 } 2861 2862 switch (TREE_CODE_LENGTH (code)) 2863 { 2864 case 1: 2865 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)); 2866 case 2: 2867 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)) 2868 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))); 2869 default: 2870 return 0; 2871 } 2872 2873 case tcc_vl_exp: 2874 switch (code) 2875 { 2876 case CALL_EXPR: 2877 { 2878 const_tree arg; 2879 const_call_expr_arg_iterator iter; 2880 FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp) 2881 if (CONTAINS_PLACEHOLDER_P (arg)) 2882 return 1; 2883 return 0; 2884 } 2885 default: 2886 return 0; 2887 } 2888 2889 default: 2890 return 0; 2891 } 2892 return 0; 2893 } 2894 2895 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR 2896 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and 2897 field positions. */ 2898 2899 static bool 2900 type_contains_placeholder_1 (const_tree type) 2901 { 2902 /* If the size contains a placeholder or the parent type (component type in 2903 the case of arrays) type involves a placeholder, this type does. */ 2904 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type)) 2905 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type)) 2906 || (!POINTER_TYPE_P (type) 2907 && TREE_TYPE (type) 2908 && type_contains_placeholder_p (TREE_TYPE (type)))) 2909 return true; 2910 2911 /* Now do type-specific checks. Note that the last part of the check above 2912 greatly limits what we have to do below. */ 2913 switch (TREE_CODE (type)) 2914 { 2915 case VOID_TYPE: 2916 case COMPLEX_TYPE: 2917 case ENUMERAL_TYPE: 2918 case BOOLEAN_TYPE: 2919 case POINTER_TYPE: 2920 case OFFSET_TYPE: 2921 case REFERENCE_TYPE: 2922 case METHOD_TYPE: 2923 case FUNCTION_TYPE: 2924 case VECTOR_TYPE: 2925 case NULLPTR_TYPE: 2926 return false; 2927 2928 case INTEGER_TYPE: 2929 case REAL_TYPE: 2930 case FIXED_POINT_TYPE: 2931 /* Here we just check the bounds. */ 2932 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type)) 2933 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type))); 2934 2935 case ARRAY_TYPE: 2936 /* We have already checked the component type above, so just check the 2937 domain type. */ 2938 return type_contains_placeholder_p (TYPE_DOMAIN (type)); 2939 2940 case RECORD_TYPE: 2941 case UNION_TYPE: 2942 case QUAL_UNION_TYPE: 2943 { 2944 tree field; 2945 2946 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 2947 if (TREE_CODE (field) == FIELD_DECL 2948 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field)) 2949 || (TREE_CODE (type) == QUAL_UNION_TYPE 2950 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field))) 2951 || type_contains_placeholder_p (TREE_TYPE (field)))) 2952 return true; 2953 2954 return false; 2955 } 2956 2957 default: 2958 gcc_unreachable (); 2959 } 2960 } 2961 2962 /* Wrapper around above function used to cache its result. */ 2963 2964 bool 2965 type_contains_placeholder_p (tree type) 2966 { 2967 bool result; 2968 2969 /* If the contains_placeholder_bits field has been initialized, 2970 then we know the answer. */ 2971 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0) 2972 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1; 2973 2974 /* Indicate that we've seen this type node, and the answer is false. 2975 This is what we want to return if we run into recursion via fields. */ 2976 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1; 2977 2978 /* Compute the real value. */ 2979 result = type_contains_placeholder_1 (type); 2980 2981 /* Store the real value. */ 2982 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1; 2983 2984 return result; 2985 } 2986 2987 /* Push tree EXP onto vector QUEUE if it is not already present. */ 2988 2989 static void 2990 push_without_duplicates (tree exp, VEC (tree, heap) **queue) 2991 { 2992 unsigned int i; 2993 tree iter; 2994 2995 FOR_EACH_VEC_ELT (tree, *queue, i, iter) 2996 if (simple_cst_equal (iter, exp) == 1) 2997 break; 2998 2999 if (!iter) 3000 VEC_safe_push (tree, heap, *queue, exp); 3001 } 3002 3003 /* Given a tree EXP, find all occurences of references to fields 3004 in a PLACEHOLDER_EXPR and place them in vector REFS without 3005 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that 3006 we assume here that EXP contains only arithmetic expressions 3007 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their 3008 argument list. */ 3009 3010 void 3011 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs) 3012 { 3013 enum tree_code code = TREE_CODE (exp); 3014 tree inner; 3015 int i; 3016 3017 /* We handle TREE_LIST and COMPONENT_REF separately. */ 3018 if (code == TREE_LIST) 3019 { 3020 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs); 3021 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs); 3022 } 3023 else if (code == COMPONENT_REF) 3024 { 3025 for (inner = TREE_OPERAND (exp, 0); 3026 REFERENCE_CLASS_P (inner); 3027 inner = TREE_OPERAND (inner, 0)) 3028 ; 3029 3030 if (TREE_CODE (inner) == PLACEHOLDER_EXPR) 3031 push_without_duplicates (exp, refs); 3032 else 3033 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs); 3034 } 3035 else 3036 switch (TREE_CODE_CLASS (code)) 3037 { 3038 case tcc_constant: 3039 break; 3040 3041 case tcc_declaration: 3042 /* Variables allocated to static storage can stay. */ 3043 if (!TREE_STATIC (exp)) 3044 push_without_duplicates (exp, refs); 3045 break; 3046 3047 case tcc_expression: 3048 /* This is the pattern built in ada/make_aligning_type. */ 3049 if (code == ADDR_EXPR 3050 && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR) 3051 { 3052 push_without_duplicates (exp, refs); 3053 break; 3054 } 3055 3056 /* Fall through... */ 3057 3058 case tcc_exceptional: 3059 case tcc_unary: 3060 case tcc_binary: 3061 case tcc_comparison: 3062 case tcc_reference: 3063 for (i = 0; i < TREE_CODE_LENGTH (code); i++) 3064 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs); 3065 break; 3066 3067 case tcc_vl_exp: 3068 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++) 3069 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs); 3070 break; 3071 3072 default: 3073 gcc_unreachable (); 3074 } 3075 } 3076 3077 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R, 3078 return a tree with all occurrences of references to F in a 3079 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and 3080 CONST_DECLs. Note that we assume here that EXP contains only 3081 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs 3082 occurring only in their argument list. */ 3083 3084 tree 3085 substitute_in_expr (tree exp, tree f, tree r) 3086 { 3087 enum tree_code code = TREE_CODE (exp); 3088 tree op0, op1, op2, op3; 3089 tree new_tree; 3090 3091 /* We handle TREE_LIST and COMPONENT_REF separately. */ 3092 if (code == TREE_LIST) 3093 { 3094 op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r); 3095 op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r); 3096 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp)) 3097 return exp; 3098 3099 return tree_cons (TREE_PURPOSE (exp), op1, op0); 3100 } 3101 else if (code == COMPONENT_REF) 3102 { 3103 tree inner; 3104 3105 /* If this expression is getting a value from a PLACEHOLDER_EXPR 3106 and it is the right field, replace it with R. */ 3107 for (inner = TREE_OPERAND (exp, 0); 3108 REFERENCE_CLASS_P (inner); 3109 inner = TREE_OPERAND (inner, 0)) 3110 ; 3111 3112 /* The field. */ 3113 op1 = TREE_OPERAND (exp, 1); 3114 3115 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f) 3116 return r; 3117 3118 /* If this expression hasn't been completed let, leave it alone. */ 3119 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner)) 3120 return exp; 3121 3122 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 3123 if (op0 == TREE_OPERAND (exp, 0)) 3124 return exp; 3125 3126 new_tree 3127 = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE); 3128 } 3129 else 3130 switch (TREE_CODE_CLASS (code)) 3131 { 3132 case tcc_constant: 3133 return exp; 3134 3135 case tcc_declaration: 3136 if (exp == f) 3137 return r; 3138 else 3139 return exp; 3140 3141 case tcc_expression: 3142 if (exp == f) 3143 return r; 3144 3145 /* Fall through... */ 3146 3147 case tcc_exceptional: 3148 case tcc_unary: 3149 case tcc_binary: 3150 case tcc_comparison: 3151 case tcc_reference: 3152 switch (TREE_CODE_LENGTH (code)) 3153 { 3154 case 0: 3155 return exp; 3156 3157 case 1: 3158 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 3159 if (op0 == TREE_OPERAND (exp, 0)) 3160 return exp; 3161 3162 new_tree = fold_build1 (code, TREE_TYPE (exp), op0); 3163 break; 3164 3165 case 2: 3166 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 3167 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r); 3168 3169 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) 3170 return exp; 3171 3172 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1); 3173 break; 3174 3175 case 3: 3176 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 3177 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r); 3178 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r); 3179 3180 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 3181 && op2 == TREE_OPERAND (exp, 2)) 3182 return exp; 3183 3184 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2); 3185 break; 3186 3187 case 4: 3188 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 3189 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r); 3190 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r); 3191 op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r); 3192 3193 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 3194 && op2 == TREE_OPERAND (exp, 2) 3195 && op3 == TREE_OPERAND (exp, 3)) 3196 return exp; 3197 3198 new_tree 3199 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3)); 3200 break; 3201 3202 default: 3203 gcc_unreachable (); 3204 } 3205 break; 3206 3207 case tcc_vl_exp: 3208 { 3209 int i; 3210 3211 new_tree = NULL_TREE; 3212 3213 /* If we are trying to replace F with a constant, inline back 3214 functions which do nothing else than computing a value from 3215 the arguments they are passed. This makes it possible to 3216 fold partially or entirely the replacement expression. */ 3217 if (CONSTANT_CLASS_P (r) && code == CALL_EXPR) 3218 { 3219 tree t = maybe_inline_call_in_expr (exp); 3220 if (t) 3221 return SUBSTITUTE_IN_EXPR (t, f, r); 3222 } 3223 3224 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++) 3225 { 3226 tree op = TREE_OPERAND (exp, i); 3227 tree new_op = SUBSTITUTE_IN_EXPR (op, f, r); 3228 if (new_op != op) 3229 { 3230 if (!new_tree) 3231 new_tree = copy_node (exp); 3232 TREE_OPERAND (new_tree, i) = new_op; 3233 } 3234 } 3235 3236 if (new_tree) 3237 { 3238 new_tree = fold (new_tree); 3239 if (TREE_CODE (new_tree) == CALL_EXPR) 3240 process_call_operands (new_tree); 3241 } 3242 else 3243 return exp; 3244 } 3245 break; 3246 3247 default: 3248 gcc_unreachable (); 3249 } 3250 3251 TREE_READONLY (new_tree) |= TREE_READONLY (exp); 3252 3253 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF) 3254 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp); 3255 3256 return new_tree; 3257 } 3258 3259 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement 3260 for it within OBJ, a tree that is an object or a chain of references. */ 3261 3262 tree 3263 substitute_placeholder_in_expr (tree exp, tree obj) 3264 { 3265 enum tree_code code = TREE_CODE (exp); 3266 tree op0, op1, op2, op3; 3267 tree new_tree; 3268 3269 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type 3270 in the chain of OBJ. */ 3271 if (code == PLACEHOLDER_EXPR) 3272 { 3273 tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp)); 3274 tree elt; 3275 3276 for (elt = obj; elt != 0; 3277 elt = ((TREE_CODE (elt) == COMPOUND_EXPR 3278 || TREE_CODE (elt) == COND_EXPR) 3279 ? TREE_OPERAND (elt, 1) 3280 : (REFERENCE_CLASS_P (elt) 3281 || UNARY_CLASS_P (elt) 3282 || BINARY_CLASS_P (elt) 3283 || VL_EXP_CLASS_P (elt) 3284 || EXPRESSION_CLASS_P (elt)) 3285 ? TREE_OPERAND (elt, 0) : 0)) 3286 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type) 3287 return elt; 3288 3289 for (elt = obj; elt != 0; 3290 elt = ((TREE_CODE (elt) == COMPOUND_EXPR 3291 || TREE_CODE (elt) == COND_EXPR) 3292 ? TREE_OPERAND (elt, 1) 3293 : (REFERENCE_CLASS_P (elt) 3294 || UNARY_CLASS_P (elt) 3295 || BINARY_CLASS_P (elt) 3296 || VL_EXP_CLASS_P (elt) 3297 || EXPRESSION_CLASS_P (elt)) 3298 ? TREE_OPERAND (elt, 0) : 0)) 3299 if (POINTER_TYPE_P (TREE_TYPE (elt)) 3300 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt))) 3301 == need_type)) 3302 return fold_build1 (INDIRECT_REF, need_type, elt); 3303 3304 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it 3305 survives until RTL generation, there will be an error. */ 3306 return exp; 3307 } 3308 3309 /* TREE_LIST is special because we need to look at TREE_VALUE 3310 and TREE_CHAIN, not TREE_OPERANDS. */ 3311 else if (code == TREE_LIST) 3312 { 3313 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj); 3314 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj); 3315 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp)) 3316 return exp; 3317 3318 return tree_cons (TREE_PURPOSE (exp), op1, op0); 3319 } 3320 else 3321 switch (TREE_CODE_CLASS (code)) 3322 { 3323 case tcc_constant: 3324 case tcc_declaration: 3325 return exp; 3326 3327 case tcc_exceptional: 3328 case tcc_unary: 3329 case tcc_binary: 3330 case tcc_comparison: 3331 case tcc_expression: 3332 case tcc_reference: 3333 case tcc_statement: 3334 switch (TREE_CODE_LENGTH (code)) 3335 { 3336 case 0: 3337 return exp; 3338 3339 case 1: 3340 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 3341 if (op0 == TREE_OPERAND (exp, 0)) 3342 return exp; 3343 3344 new_tree = fold_build1 (code, TREE_TYPE (exp), op0); 3345 break; 3346 3347 case 2: 3348 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 3349 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj); 3350 3351 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) 3352 return exp; 3353 3354 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1); 3355 break; 3356 3357 case 3: 3358 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 3359 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj); 3360 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj); 3361 3362 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 3363 && op2 == TREE_OPERAND (exp, 2)) 3364 return exp; 3365 3366 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2); 3367 break; 3368 3369 case 4: 3370 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 3371 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj); 3372 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj); 3373 op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj); 3374 3375 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 3376 && op2 == TREE_OPERAND (exp, 2) 3377 && op3 == TREE_OPERAND (exp, 3)) 3378 return exp; 3379 3380 new_tree 3381 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3)); 3382 break; 3383 3384 default: 3385 gcc_unreachable (); 3386 } 3387 break; 3388 3389 case tcc_vl_exp: 3390 { 3391 int i; 3392 3393 new_tree = NULL_TREE; 3394 3395 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++) 3396 { 3397 tree op = TREE_OPERAND (exp, i); 3398 tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj); 3399 if (new_op != op) 3400 { 3401 if (!new_tree) 3402 new_tree = copy_node (exp); 3403 TREE_OPERAND (new_tree, i) = new_op; 3404 } 3405 } 3406 3407 if (new_tree) 3408 { 3409 new_tree = fold (new_tree); 3410 if (TREE_CODE (new_tree) == CALL_EXPR) 3411 process_call_operands (new_tree); 3412 } 3413 else 3414 return exp; 3415 } 3416 break; 3417 3418 default: 3419 gcc_unreachable (); 3420 } 3421 3422 TREE_READONLY (new_tree) |= TREE_READONLY (exp); 3423 3424 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF) 3425 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp); 3426 3427 return new_tree; 3428 } 3429 3430 /* Stabilize a reference so that we can use it any number of times 3431 without causing its operands to be evaluated more than once. 3432 Returns the stabilized reference. This works by means of save_expr, 3433 so see the caveats in the comments about save_expr. 3434 3435 Also allows conversion expressions whose operands are references. 3436 Any other kind of expression is returned unchanged. */ 3437 3438 tree 3439 stabilize_reference (tree ref) 3440 { 3441 tree result; 3442 enum tree_code code = TREE_CODE (ref); 3443 3444 switch (code) 3445 { 3446 case VAR_DECL: 3447 case PARM_DECL: 3448 case RESULT_DECL: 3449 /* No action is needed in this case. */ 3450 return ref; 3451 3452 CASE_CONVERT: 3453 case FLOAT_EXPR: 3454 case FIX_TRUNC_EXPR: 3455 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0))); 3456 break; 3457 3458 case INDIRECT_REF: 3459 result = build_nt (INDIRECT_REF, 3460 stabilize_reference_1 (TREE_OPERAND (ref, 0))); 3461 break; 3462 3463 case COMPONENT_REF: 3464 result = build_nt (COMPONENT_REF, 3465 stabilize_reference (TREE_OPERAND (ref, 0)), 3466 TREE_OPERAND (ref, 1), NULL_TREE); 3467 break; 3468 3469 case BIT_FIELD_REF: 3470 result = build_nt (BIT_FIELD_REF, 3471 stabilize_reference (TREE_OPERAND (ref, 0)), 3472 stabilize_reference_1 (TREE_OPERAND (ref, 1)), 3473 stabilize_reference_1 (TREE_OPERAND (ref, 2))); 3474 break; 3475 3476 case ARRAY_REF: 3477 result = build_nt (ARRAY_REF, 3478 stabilize_reference (TREE_OPERAND (ref, 0)), 3479 stabilize_reference_1 (TREE_OPERAND (ref, 1)), 3480 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); 3481 break; 3482 3483 case ARRAY_RANGE_REF: 3484 result = build_nt (ARRAY_RANGE_REF, 3485 stabilize_reference (TREE_OPERAND (ref, 0)), 3486 stabilize_reference_1 (TREE_OPERAND (ref, 1)), 3487 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); 3488 break; 3489 3490 case COMPOUND_EXPR: 3491 /* We cannot wrap the first expression in a SAVE_EXPR, as then 3492 it wouldn't be ignored. This matters when dealing with 3493 volatiles. */ 3494 return stabilize_reference_1 (ref); 3495 3496 /* If arg isn't a kind of lvalue we recognize, make no change. 3497 Caller should recognize the error for an invalid lvalue. */ 3498 default: 3499 return ref; 3500 3501 case ERROR_MARK: 3502 return error_mark_node; 3503 } 3504 3505 TREE_TYPE (result) = TREE_TYPE (ref); 3506 TREE_READONLY (result) = TREE_READONLY (ref); 3507 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref); 3508 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref); 3509 3510 return result; 3511 } 3512 3513 /* Subroutine of stabilize_reference; this is called for subtrees of 3514 references. Any expression with side-effects must be put in a SAVE_EXPR 3515 to ensure that it is only evaluated once. 3516 3517 We don't put SAVE_EXPR nodes around everything, because assigning very 3518 simple expressions to temporaries causes us to miss good opportunities 3519 for optimizations. Among other things, the opportunity to fold in the 3520 addition of a constant into an addressing mode often gets lost, e.g. 3521 "y[i+1] += x;". In general, we take the approach that we should not make 3522 an assignment unless we are forced into it - i.e., that any non-side effect 3523 operator should be allowed, and that cse should take care of coalescing 3524 multiple utterances of the same expression should that prove fruitful. */ 3525 3526 tree 3527 stabilize_reference_1 (tree e) 3528 { 3529 tree result; 3530 enum tree_code code = TREE_CODE (e); 3531 3532 /* We cannot ignore const expressions because it might be a reference 3533 to a const array but whose index contains side-effects. But we can 3534 ignore things that are actual constant or that already have been 3535 handled by this function. */ 3536 3537 if (tree_invariant_p (e)) 3538 return e; 3539 3540 switch (TREE_CODE_CLASS (code)) 3541 { 3542 case tcc_exceptional: 3543 case tcc_type: 3544 case tcc_declaration: 3545 case tcc_comparison: 3546 case tcc_statement: 3547 case tcc_expression: 3548 case tcc_reference: 3549 case tcc_vl_exp: 3550 /* If the expression has side-effects, then encase it in a SAVE_EXPR 3551 so that it will only be evaluated once. */ 3552 /* The reference (r) and comparison (<) classes could be handled as 3553 below, but it is generally faster to only evaluate them once. */ 3554 if (TREE_SIDE_EFFECTS (e)) 3555 return save_expr (e); 3556 return e; 3557 3558 case tcc_constant: 3559 /* Constants need no processing. In fact, we should never reach 3560 here. */ 3561 return e; 3562 3563 case tcc_binary: 3564 /* Division is slow and tends to be compiled with jumps, 3565 especially the division by powers of 2 that is often 3566 found inside of an array reference. So do it just once. */ 3567 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR 3568 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR 3569 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR 3570 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR) 3571 return save_expr (e); 3572 /* Recursively stabilize each operand. */ 3573 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)), 3574 stabilize_reference_1 (TREE_OPERAND (e, 1))); 3575 break; 3576 3577 case tcc_unary: 3578 /* Recursively stabilize each operand. */ 3579 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0))); 3580 break; 3581 3582 default: 3583 gcc_unreachable (); 3584 } 3585 3586 TREE_TYPE (result) = TREE_TYPE (e); 3587 TREE_READONLY (result) = TREE_READONLY (e); 3588 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e); 3589 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e); 3590 3591 return result; 3592 } 3593 3594 /* Low-level constructors for expressions. */ 3595 3596 /* A helper function for build1 and constant folders. Set TREE_CONSTANT, 3597 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */ 3598 3599 void 3600 recompute_tree_invariant_for_addr_expr (tree t) 3601 { 3602 tree node; 3603 bool tc = true, se = false; 3604 3605 /* We started out assuming this address is both invariant and constant, but 3606 does not have side effects. Now go down any handled components and see if 3607 any of them involve offsets that are either non-constant or non-invariant. 3608 Also check for side-effects. 3609 3610 ??? Note that this code makes no attempt to deal with the case where 3611 taking the address of something causes a copy due to misalignment. */ 3612 3613 #define UPDATE_FLAGS(NODE) \ 3614 do { tree _node = (NODE); \ 3615 if (_node && !TREE_CONSTANT (_node)) tc = false; \ 3616 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0) 3617 3618 for (node = TREE_OPERAND (t, 0); handled_component_p (node); 3619 node = TREE_OPERAND (node, 0)) 3620 { 3621 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus 3622 array reference (probably made temporarily by the G++ front end), 3623 so ignore all the operands. */ 3624 if ((TREE_CODE (node) == ARRAY_REF 3625 || TREE_CODE (node) == ARRAY_RANGE_REF) 3626 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE) 3627 { 3628 UPDATE_FLAGS (TREE_OPERAND (node, 1)); 3629 if (TREE_OPERAND (node, 2)) 3630 UPDATE_FLAGS (TREE_OPERAND (node, 2)); 3631 if (TREE_OPERAND (node, 3)) 3632 UPDATE_FLAGS (TREE_OPERAND (node, 3)); 3633 } 3634 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a 3635 FIELD_DECL, apparently. The G++ front end can put something else 3636 there, at least temporarily. */ 3637 else if (TREE_CODE (node) == COMPONENT_REF 3638 && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL) 3639 { 3640 if (TREE_OPERAND (node, 2)) 3641 UPDATE_FLAGS (TREE_OPERAND (node, 2)); 3642 } 3643 else if (TREE_CODE (node) == BIT_FIELD_REF) 3644 UPDATE_FLAGS (TREE_OPERAND (node, 2)); 3645 } 3646 3647 node = lang_hooks.expr_to_decl (node, &tc, &se); 3648 3649 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from 3650 the address, since &(*a)->b is a form of addition. If it's a constant, the 3651 address is constant too. If it's a decl, its address is constant if the 3652 decl is static. Everything else is not constant and, furthermore, 3653 taking the address of a volatile variable is not volatile. */ 3654 if (TREE_CODE (node) == INDIRECT_REF 3655 || TREE_CODE (node) == MEM_REF) 3656 UPDATE_FLAGS (TREE_OPERAND (node, 0)); 3657 else if (CONSTANT_CLASS_P (node)) 3658 ; 3659 else if (DECL_P (node)) 3660 tc &= (staticp (node) != NULL_TREE); 3661 else 3662 { 3663 tc = false; 3664 se |= TREE_SIDE_EFFECTS (node); 3665 } 3666 3667 3668 TREE_CONSTANT (t) = tc; 3669 TREE_SIDE_EFFECTS (t) = se; 3670 #undef UPDATE_FLAGS 3671 } 3672 3673 /* Build an expression of code CODE, data type TYPE, and operands as 3674 specified. Expressions and reference nodes can be created this way. 3675 Constants, decls, types and misc nodes cannot be. 3676 3677 We define 5 non-variadic functions, from 0 to 4 arguments. This is 3678 enough for all extant tree codes. */ 3679 3680 tree 3681 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL) 3682 { 3683 tree t; 3684 3685 gcc_assert (TREE_CODE_LENGTH (code) == 0); 3686 3687 t = make_node_stat (code PASS_MEM_STAT); 3688 TREE_TYPE (t) = tt; 3689 3690 return t; 3691 } 3692 3693 tree 3694 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL) 3695 { 3696 int length = sizeof (struct tree_exp); 3697 tree t; 3698 3699 record_node_allocation_statistics (code, length); 3700 3701 gcc_assert (TREE_CODE_LENGTH (code) == 1); 3702 3703 t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT); 3704 3705 memset (t, 0, sizeof (struct tree_common)); 3706 3707 TREE_SET_CODE (t, code); 3708 3709 TREE_TYPE (t) = type; 3710 SET_EXPR_LOCATION (t, UNKNOWN_LOCATION); 3711 TREE_OPERAND (t, 0) = node; 3712 TREE_BLOCK (t) = NULL_TREE; 3713 if (node && !TYPE_P (node)) 3714 { 3715 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node); 3716 TREE_READONLY (t) = TREE_READONLY (node); 3717 } 3718 3719 if (TREE_CODE_CLASS (code) == tcc_statement) 3720 TREE_SIDE_EFFECTS (t) = 1; 3721 else switch (code) 3722 { 3723 case VA_ARG_EXPR: 3724 /* All of these have side-effects, no matter what their 3725 operands are. */ 3726 TREE_SIDE_EFFECTS (t) = 1; 3727 TREE_READONLY (t) = 0; 3728 break; 3729 3730 case INDIRECT_REF: 3731 /* Whether a dereference is readonly has nothing to do with whether 3732 its operand is readonly. */ 3733 TREE_READONLY (t) = 0; 3734 break; 3735 3736 case ADDR_EXPR: 3737 if (node) 3738 recompute_tree_invariant_for_addr_expr (t); 3739 break; 3740 3741 default: 3742 if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR) 3743 && node && !TYPE_P (node) 3744 && TREE_CONSTANT (node)) 3745 TREE_CONSTANT (t) = 1; 3746 if (TREE_CODE_CLASS (code) == tcc_reference 3747 && node && TREE_THIS_VOLATILE (node)) 3748 TREE_THIS_VOLATILE (t) = 1; 3749 break; 3750 } 3751 3752 return t; 3753 } 3754 3755 #define PROCESS_ARG(N) \ 3756 do { \ 3757 TREE_OPERAND (t, N) = arg##N; \ 3758 if (arg##N &&!TYPE_P (arg##N)) \ 3759 { \ 3760 if (TREE_SIDE_EFFECTS (arg##N)) \ 3761 side_effects = 1; \ 3762 if (!TREE_READONLY (arg##N) \ 3763 && !CONSTANT_CLASS_P (arg##N)) \ 3764 (void) (read_only = 0); \ 3765 if (!TREE_CONSTANT (arg##N)) \ 3766 (void) (constant = 0); \ 3767 } \ 3768 } while (0) 3769 3770 tree 3771 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL) 3772 { 3773 bool constant, read_only, side_effects; 3774 tree t; 3775 3776 gcc_assert (TREE_CODE_LENGTH (code) == 2); 3777 3778 if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR) 3779 && arg0 && arg1 && tt && POINTER_TYPE_P (tt) 3780 /* When sizetype precision doesn't match that of pointers 3781 we need to be able to build explicit extensions or truncations 3782 of the offset argument. */ 3783 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt)) 3784 gcc_assert (TREE_CODE (arg0) == INTEGER_CST 3785 && TREE_CODE (arg1) == INTEGER_CST); 3786 3787 if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt) 3788 gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0)) 3789 && ptrofftype_p (TREE_TYPE (arg1))); 3790 3791 t = make_node_stat (code PASS_MEM_STAT); 3792 TREE_TYPE (t) = tt; 3793 3794 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the 3795 result based on those same flags for the arguments. But if the 3796 arguments aren't really even `tree' expressions, we shouldn't be trying 3797 to do this. */ 3798 3799 /* Expressions without side effects may be constant if their 3800 arguments are as well. */ 3801 constant = (TREE_CODE_CLASS (code) == tcc_comparison 3802 || TREE_CODE_CLASS (code) == tcc_binary); 3803 read_only = 1; 3804 side_effects = TREE_SIDE_EFFECTS (t); 3805 3806 PROCESS_ARG(0); 3807 PROCESS_ARG(1); 3808 3809 TREE_READONLY (t) = read_only; 3810 TREE_CONSTANT (t) = constant; 3811 TREE_SIDE_EFFECTS (t) = side_effects; 3812 TREE_THIS_VOLATILE (t) 3813 = (TREE_CODE_CLASS (code) == tcc_reference 3814 && arg0 && TREE_THIS_VOLATILE (arg0)); 3815 3816 return t; 3817 } 3818 3819 3820 tree 3821 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3822 tree arg2 MEM_STAT_DECL) 3823 { 3824 bool constant, read_only, side_effects; 3825 tree t; 3826 3827 gcc_assert (TREE_CODE_LENGTH (code) == 3); 3828 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp); 3829 3830 t = make_node_stat (code PASS_MEM_STAT); 3831 TREE_TYPE (t) = tt; 3832 3833 read_only = 1; 3834 3835 /* As a special exception, if COND_EXPR has NULL branches, we 3836 assume that it is a gimple statement and always consider 3837 it to have side effects. */ 3838 if (code == COND_EXPR 3839 && tt == void_type_node 3840 && arg1 == NULL_TREE 3841 && arg2 == NULL_TREE) 3842 side_effects = true; 3843 else 3844 side_effects = TREE_SIDE_EFFECTS (t); 3845 3846 PROCESS_ARG(0); 3847 PROCESS_ARG(1); 3848 PROCESS_ARG(2); 3849 3850 if (code == COND_EXPR) 3851 TREE_READONLY (t) = read_only; 3852 3853 TREE_SIDE_EFFECTS (t) = side_effects; 3854 TREE_THIS_VOLATILE (t) 3855 = (TREE_CODE_CLASS (code) == tcc_reference 3856 && arg0 && TREE_THIS_VOLATILE (arg0)); 3857 3858 return t; 3859 } 3860 3861 tree 3862 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3863 tree arg2, tree arg3 MEM_STAT_DECL) 3864 { 3865 bool constant, read_only, side_effects; 3866 tree t; 3867 3868 gcc_assert (TREE_CODE_LENGTH (code) == 4); 3869 3870 t = make_node_stat (code PASS_MEM_STAT); 3871 TREE_TYPE (t) = tt; 3872 3873 side_effects = TREE_SIDE_EFFECTS (t); 3874 3875 PROCESS_ARG(0); 3876 PROCESS_ARG(1); 3877 PROCESS_ARG(2); 3878 PROCESS_ARG(3); 3879 3880 TREE_SIDE_EFFECTS (t) = side_effects; 3881 TREE_THIS_VOLATILE (t) 3882 = (TREE_CODE_CLASS (code) == tcc_reference 3883 && arg0 && TREE_THIS_VOLATILE (arg0)); 3884 3885 return t; 3886 } 3887 3888 tree 3889 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3890 tree arg2, tree arg3, tree arg4 MEM_STAT_DECL) 3891 { 3892 bool constant, read_only, side_effects; 3893 tree t; 3894 3895 gcc_assert (TREE_CODE_LENGTH (code) == 5); 3896 3897 t = make_node_stat (code PASS_MEM_STAT); 3898 TREE_TYPE (t) = tt; 3899 3900 side_effects = TREE_SIDE_EFFECTS (t); 3901 3902 PROCESS_ARG(0); 3903 PROCESS_ARG(1); 3904 PROCESS_ARG(2); 3905 PROCESS_ARG(3); 3906 PROCESS_ARG(4); 3907 3908 TREE_SIDE_EFFECTS (t) = side_effects; 3909 TREE_THIS_VOLATILE (t) 3910 = (TREE_CODE_CLASS (code) == tcc_reference 3911 && arg0 && TREE_THIS_VOLATILE (arg0)); 3912 3913 return t; 3914 } 3915 3916 tree 3917 build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3918 tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL) 3919 { 3920 bool constant, read_only, side_effects; 3921 tree t; 3922 3923 gcc_assert (code == TARGET_MEM_REF); 3924 3925 t = make_node_stat (code PASS_MEM_STAT); 3926 TREE_TYPE (t) = tt; 3927 3928 side_effects = TREE_SIDE_EFFECTS (t); 3929 3930 PROCESS_ARG(0); 3931 PROCESS_ARG(1); 3932 PROCESS_ARG(2); 3933 PROCESS_ARG(3); 3934 PROCESS_ARG(4); 3935 if (code == TARGET_MEM_REF) 3936 side_effects = 0; 3937 PROCESS_ARG(5); 3938 3939 TREE_SIDE_EFFECTS (t) = side_effects; 3940 TREE_THIS_VOLATILE (t) 3941 = (code == TARGET_MEM_REF 3942 && arg5 && TREE_THIS_VOLATILE (arg5)); 3943 3944 return t; 3945 } 3946 3947 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF 3948 on the pointer PTR. */ 3949 3950 tree 3951 build_simple_mem_ref_loc (location_t loc, tree ptr) 3952 { 3953 HOST_WIDE_INT offset = 0; 3954 tree ptype = TREE_TYPE (ptr); 3955 tree tem; 3956 /* For convenience allow addresses that collapse to a simple base 3957 and offset. */ 3958 if (TREE_CODE (ptr) == ADDR_EXPR 3959 && (handled_component_p (TREE_OPERAND (ptr, 0)) 3960 || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF)) 3961 { 3962 ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset); 3963 gcc_assert (ptr); 3964 ptr = build_fold_addr_expr (ptr); 3965 gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr)); 3966 } 3967 tem = build2 (MEM_REF, TREE_TYPE (ptype), 3968 ptr, build_int_cst (ptype, offset)); 3969 SET_EXPR_LOCATION (tem, loc); 3970 return tem; 3971 } 3972 3973 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */ 3974 3975 double_int 3976 mem_ref_offset (const_tree t) 3977 { 3978 tree toff = TREE_OPERAND (t, 1); 3979 return double_int_sext (tree_to_double_int (toff), 3980 TYPE_PRECISION (TREE_TYPE (toff))); 3981 } 3982 3983 /* Return the pointer-type relevant for TBAA purposes from the 3984 gimple memory reference tree T. This is the type to be used for 3985 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T. */ 3986 3987 tree 3988 reference_alias_ptr_type (const_tree t) 3989 { 3990 const_tree base = t; 3991 while (handled_component_p (base)) 3992 base = TREE_OPERAND (base, 0); 3993 if (TREE_CODE (base) == MEM_REF) 3994 return TREE_TYPE (TREE_OPERAND (base, 1)); 3995 else if (TREE_CODE (base) == TARGET_MEM_REF) 3996 return TREE_TYPE (TMR_OFFSET (base)); 3997 else 3998 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (base))); 3999 } 4000 4001 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE 4002 offsetted by OFFSET units. */ 4003 4004 tree 4005 build_invariant_address (tree type, tree base, HOST_WIDE_INT offset) 4006 { 4007 tree ref = fold_build2 (MEM_REF, TREE_TYPE (type), 4008 build_fold_addr_expr (base), 4009 build_int_cst (ptr_type_node, offset)); 4010 tree addr = build1 (ADDR_EXPR, type, ref); 4011 recompute_tree_invariant_for_addr_expr (addr); 4012 return addr; 4013 } 4014 4015 /* Similar except don't specify the TREE_TYPE 4016 and leave the TREE_SIDE_EFFECTS as 0. 4017 It is permissible for arguments to be null, 4018 or even garbage if their values do not matter. */ 4019 4020 tree 4021 build_nt (enum tree_code code, ...) 4022 { 4023 tree t; 4024 int length; 4025 int i; 4026 va_list p; 4027 4028 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp); 4029 4030 va_start (p, code); 4031 4032 t = make_node (code); 4033 length = TREE_CODE_LENGTH (code); 4034 4035 for (i = 0; i < length; i++) 4036 TREE_OPERAND (t, i) = va_arg (p, tree); 4037 4038 va_end (p); 4039 return t; 4040 } 4041 4042 /* Similar to build_nt, but for creating a CALL_EXPR object with a 4043 tree VEC. */ 4044 4045 tree 4046 build_nt_call_vec (tree fn, VEC(tree,gc) *args) 4047 { 4048 tree ret, t; 4049 unsigned int ix; 4050 4051 ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3); 4052 CALL_EXPR_FN (ret) = fn; 4053 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE; 4054 FOR_EACH_VEC_ELT (tree, args, ix, t) 4055 CALL_EXPR_ARG (ret, ix) = t; 4056 return ret; 4057 } 4058 4059 /* Create a DECL_... node of code CODE, name NAME and data type TYPE. 4060 We do NOT enter this node in any sort of symbol table. 4061 4062 LOC is the location of the decl. 4063 4064 layout_decl is used to set up the decl's storage layout. 4065 Other slots are initialized to 0 or null pointers. */ 4066 4067 tree 4068 build_decl_stat (location_t loc, enum tree_code code, tree name, 4069 tree type MEM_STAT_DECL) 4070 { 4071 tree t; 4072 4073 t = make_node_stat (code PASS_MEM_STAT); 4074 DECL_SOURCE_LOCATION (t) = loc; 4075 4076 /* if (type == error_mark_node) 4077 type = integer_type_node; */ 4078 /* That is not done, deliberately, so that having error_mark_node 4079 as the type can suppress useless errors in the use of this variable. */ 4080 4081 DECL_NAME (t) = name; 4082 TREE_TYPE (t) = type; 4083 4084 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL) 4085 layout_decl (t, 0); 4086 4087 return t; 4088 } 4089 4090 /* Builds and returns function declaration with NAME and TYPE. */ 4091 4092 tree 4093 build_fn_decl (const char *name, tree type) 4094 { 4095 tree id = get_identifier (name); 4096 tree decl = build_decl (input_location, FUNCTION_DECL, id, type); 4097 4098 DECL_EXTERNAL (decl) = 1; 4099 TREE_PUBLIC (decl) = 1; 4100 DECL_ARTIFICIAL (decl) = 1; 4101 TREE_NOTHROW (decl) = 1; 4102 4103 return decl; 4104 } 4105 4106 VEC(tree,gc) *all_translation_units; 4107 4108 /* Builds a new translation-unit decl with name NAME, queues it in the 4109 global list of translation-unit decls and returns it. */ 4110 4111 tree 4112 build_translation_unit_decl (tree name) 4113 { 4114 tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL, 4115 name, NULL_TREE); 4116 TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name; 4117 VEC_safe_push (tree, gc, all_translation_units, tu); 4118 return tu; 4119 } 4120 4121 4122 /* BLOCK nodes are used to represent the structure of binding contours 4123 and declarations, once those contours have been exited and their contents 4124 compiled. This information is used for outputting debugging info. */ 4125 4126 tree 4127 build_block (tree vars, tree subblocks, tree supercontext, tree chain) 4128 { 4129 tree block = make_node (BLOCK); 4130 4131 BLOCK_VARS (block) = vars; 4132 BLOCK_SUBBLOCKS (block) = subblocks; 4133 BLOCK_SUPERCONTEXT (block) = supercontext; 4134 BLOCK_CHAIN (block) = chain; 4135 return block; 4136 } 4137 4138 4139 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location. 4140 4141 LOC is the location to use in tree T. */ 4142 4143 void 4144 protected_set_expr_location (tree t, location_t loc) 4145 { 4146 if (t && CAN_HAVE_LOCATION_P (t)) 4147 SET_EXPR_LOCATION (t, loc); 4148 } 4149 4150 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES 4151 is ATTRIBUTE. */ 4152 4153 tree 4154 build_decl_attribute_variant (tree ddecl, tree attribute) 4155 { 4156 DECL_ATTRIBUTES (ddecl) = attribute; 4157 return ddecl; 4158 } 4159 4160 /* Borrowed from hashtab.c iterative_hash implementation. */ 4161 #define mix(a,b,c) \ 4162 { \ 4163 a -= b; a -= c; a ^= (c>>13); \ 4164 b -= c; b -= a; b ^= (a<< 8); \ 4165 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \ 4166 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \ 4167 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \ 4168 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \ 4169 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \ 4170 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \ 4171 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \ 4172 } 4173 4174 4175 /* Produce good hash value combining VAL and VAL2. */ 4176 hashval_t 4177 iterative_hash_hashval_t (hashval_t val, hashval_t val2) 4178 { 4179 /* the golden ratio; an arbitrary value. */ 4180 hashval_t a = 0x9e3779b9; 4181 4182 mix (a, val, val2); 4183 return val2; 4184 } 4185 4186 /* Produce good hash value combining VAL and VAL2. */ 4187 hashval_t 4188 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2) 4189 { 4190 if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t)) 4191 return iterative_hash_hashval_t (val, val2); 4192 else 4193 { 4194 hashval_t a = (hashval_t) val; 4195 /* Avoid warnings about shifting of more than the width of the type on 4196 hosts that won't execute this path. */ 4197 int zero = 0; 4198 hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero)); 4199 mix (a, b, val2); 4200 if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t)) 4201 { 4202 hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero)); 4203 hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero)); 4204 mix (a, b, val2); 4205 } 4206 return val2; 4207 } 4208 } 4209 4210 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE 4211 is ATTRIBUTE and its qualifiers are QUALS. 4212 4213 Record such modified types already made so we don't make duplicates. */ 4214 4215 tree 4216 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals) 4217 { 4218 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute)) 4219 { 4220 hashval_t hashcode = 0; 4221 tree ntype; 4222 enum tree_code code = TREE_CODE (ttype); 4223 4224 /* Building a distinct copy of a tagged type is inappropriate; it 4225 causes breakage in code that expects there to be a one-to-one 4226 relationship between a struct and its fields. 4227 build_duplicate_type is another solution (as used in 4228 handle_transparent_union_attribute), but that doesn't play well 4229 with the stronger C++ type identity model. */ 4230 if (TREE_CODE (ttype) == RECORD_TYPE 4231 || TREE_CODE (ttype) == UNION_TYPE 4232 || TREE_CODE (ttype) == QUAL_UNION_TYPE 4233 || TREE_CODE (ttype) == ENUMERAL_TYPE) 4234 { 4235 warning (OPT_Wattributes, 4236 "ignoring attributes applied to %qT after definition", 4237 TYPE_MAIN_VARIANT (ttype)); 4238 return build_qualified_type (ttype, quals); 4239 } 4240 4241 ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED); 4242 ntype = build_distinct_type_copy (ttype); 4243 4244 TYPE_ATTRIBUTES (ntype) = attribute; 4245 4246 hashcode = iterative_hash_object (code, hashcode); 4247 if (TREE_TYPE (ntype)) 4248 hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)), 4249 hashcode); 4250 hashcode = attribute_hash_list (attribute, hashcode); 4251 4252 switch (TREE_CODE (ntype)) 4253 { 4254 case FUNCTION_TYPE: 4255 hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode); 4256 break; 4257 case ARRAY_TYPE: 4258 if (TYPE_DOMAIN (ntype)) 4259 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)), 4260 hashcode); 4261 break; 4262 case INTEGER_TYPE: 4263 hashcode = iterative_hash_object 4264 (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode); 4265 hashcode = iterative_hash_object 4266 (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode); 4267 break; 4268 case REAL_TYPE: 4269 case FIXED_POINT_TYPE: 4270 { 4271 unsigned int precision = TYPE_PRECISION (ntype); 4272 hashcode = iterative_hash_object (precision, hashcode); 4273 } 4274 break; 4275 default: 4276 break; 4277 } 4278 4279 ntype = type_hash_canon (hashcode, ntype); 4280 4281 /* If the target-dependent attributes make NTYPE different from 4282 its canonical type, we will need to use structural equality 4283 checks for this type. */ 4284 if (TYPE_STRUCTURAL_EQUALITY_P (ttype) 4285 || !comp_type_attributes (ntype, ttype)) 4286 SET_TYPE_STRUCTURAL_EQUALITY (ntype); 4287 else if (TYPE_CANONICAL (ntype) == ntype) 4288 TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype); 4289 4290 ttype = build_qualified_type (ntype, quals); 4291 } 4292 else if (TYPE_QUALS (ttype) != quals) 4293 ttype = build_qualified_type (ttype, quals); 4294 4295 return ttype; 4296 } 4297 4298 /* Compare two attributes for their value identity. Return true if the 4299 attribute values are known to be equal; otherwise return false. 4300 */ 4301 4302 static bool 4303 attribute_value_equal (const_tree attr1, const_tree attr2) 4304 { 4305 if (TREE_VALUE (attr1) == TREE_VALUE (attr2)) 4306 return true; 4307 4308 if (TREE_VALUE (attr1) != NULL_TREE 4309 && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST 4310 && TREE_VALUE (attr2) != NULL 4311 && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST) 4312 return (simple_cst_list_equal (TREE_VALUE (attr1), 4313 TREE_VALUE (attr2)) == 1); 4314 4315 return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1); 4316 } 4317 4318 /* Return 0 if the attributes for two types are incompatible, 1 if they 4319 are compatible, and 2 if they are nearly compatible (which causes a 4320 warning to be generated). */ 4321 int 4322 comp_type_attributes (const_tree type1, const_tree type2) 4323 { 4324 const_tree a1 = TYPE_ATTRIBUTES (type1); 4325 const_tree a2 = TYPE_ATTRIBUTES (type2); 4326 const_tree a; 4327 4328 if (a1 == a2) 4329 return 1; 4330 for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a)) 4331 { 4332 const struct attribute_spec *as; 4333 const_tree attr; 4334 4335 as = lookup_attribute_spec (TREE_PURPOSE (a)); 4336 if (!as || as->affects_type_identity == false) 4337 continue; 4338 4339 attr = lookup_attribute (as->name, CONST_CAST_TREE (a2)); 4340 if (!attr || !attribute_value_equal (a, attr)) 4341 break; 4342 } 4343 if (!a) 4344 { 4345 for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a)) 4346 { 4347 const struct attribute_spec *as; 4348 4349 as = lookup_attribute_spec (TREE_PURPOSE (a)); 4350 if (!as || as->affects_type_identity == false) 4351 continue; 4352 4353 if (!lookup_attribute (as->name, CONST_CAST_TREE (a1))) 4354 break; 4355 /* We don't need to compare trees again, as we did this 4356 already in first loop. */ 4357 } 4358 /* All types - affecting identity - are equal, so 4359 there is no need to call target hook for comparison. */ 4360 if (!a) 4361 return 1; 4362 } 4363 /* As some type combinations - like default calling-convention - might 4364 be compatible, we have to call the target hook to get the final result. */ 4365 return targetm.comp_type_attributes (type1, type2); 4366 } 4367 4368 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE 4369 is ATTRIBUTE. 4370 4371 Record such modified types already made so we don't make duplicates. */ 4372 4373 tree 4374 build_type_attribute_variant (tree ttype, tree attribute) 4375 { 4376 return build_type_attribute_qual_variant (ttype, attribute, 4377 TYPE_QUALS (ttype)); 4378 } 4379 4380 4381 /* Reset the expression *EXPR_P, a size or position. 4382 4383 ??? We could reset all non-constant sizes or positions. But it's cheap 4384 enough to not do so and refrain from adding workarounds to dwarf2out.c. 4385 4386 We need to reset self-referential sizes or positions because they cannot 4387 be gimplified and thus can contain a CALL_EXPR after the gimplification 4388 is finished, which will run afoul of LTO streaming. And they need to be 4389 reset to something essentially dummy but not constant, so as to preserve 4390 the properties of the object they are attached to. */ 4391 4392 static inline void 4393 free_lang_data_in_one_sizepos (tree *expr_p) 4394 { 4395 tree expr = *expr_p; 4396 if (CONTAINS_PLACEHOLDER_P (expr)) 4397 *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr)); 4398 } 4399 4400 4401 /* Reset all the fields in a binfo node BINFO. We only keep 4402 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */ 4403 4404 static void 4405 free_lang_data_in_binfo (tree binfo) 4406 { 4407 unsigned i; 4408 tree t; 4409 4410 gcc_assert (TREE_CODE (binfo) == TREE_BINFO); 4411 4412 BINFO_VIRTUALS (binfo) = NULL_TREE; 4413 BINFO_BASE_ACCESSES (binfo) = NULL; 4414 BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE; 4415 BINFO_SUBVTT_INDEX (binfo) = NULL_TREE; 4416 4417 FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (binfo), i, t) 4418 free_lang_data_in_binfo (t); 4419 } 4420 4421 4422 /* Reset all language specific information still present in TYPE. */ 4423 4424 static void 4425 free_lang_data_in_type (tree type) 4426 { 4427 gcc_assert (TYPE_P (type)); 4428 4429 /* Give the FE a chance to remove its own data first. */ 4430 lang_hooks.free_lang_data (type); 4431 4432 TREE_LANG_FLAG_0 (type) = 0; 4433 TREE_LANG_FLAG_1 (type) = 0; 4434 TREE_LANG_FLAG_2 (type) = 0; 4435 TREE_LANG_FLAG_3 (type) = 0; 4436 TREE_LANG_FLAG_4 (type) = 0; 4437 TREE_LANG_FLAG_5 (type) = 0; 4438 TREE_LANG_FLAG_6 (type) = 0; 4439 4440 if (TREE_CODE (type) == FUNCTION_TYPE) 4441 { 4442 /* Remove the const and volatile qualifiers from arguments. The 4443 C++ front end removes them, but the C front end does not, 4444 leading to false ODR violation errors when merging two 4445 instances of the same function signature compiled by 4446 different front ends. */ 4447 tree p; 4448 4449 for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p)) 4450 { 4451 tree arg_type = TREE_VALUE (p); 4452 4453 if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type)) 4454 { 4455 int quals = TYPE_QUALS (arg_type) 4456 & ~TYPE_QUAL_CONST 4457 & ~TYPE_QUAL_VOLATILE; 4458 TREE_VALUE (p) = build_qualified_type (arg_type, quals); 4459 free_lang_data_in_type (TREE_VALUE (p)); 4460 } 4461 } 4462 } 4463 4464 /* Remove members that are not actually FIELD_DECLs from the field 4465 list of an aggregate. These occur in C++. */ 4466 if (RECORD_OR_UNION_TYPE_P (type)) 4467 { 4468 tree prev, member; 4469 4470 /* Note that TYPE_FIELDS can be shared across distinct 4471 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is 4472 to be removed, we cannot set its TREE_CHAIN to NULL. 4473 Otherwise, we would not be able to find all the other fields 4474 in the other instances of this TREE_TYPE. 4475 4476 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */ 4477 prev = NULL_TREE; 4478 member = TYPE_FIELDS (type); 4479 while (member) 4480 { 4481 if (TREE_CODE (member) == FIELD_DECL 4482 || TREE_CODE (member) == TYPE_DECL) 4483 { 4484 if (prev) 4485 TREE_CHAIN (prev) = member; 4486 else 4487 TYPE_FIELDS (type) = member; 4488 prev = member; 4489 } 4490 4491 member = TREE_CHAIN (member); 4492 } 4493 4494 if (prev) 4495 TREE_CHAIN (prev) = NULL_TREE; 4496 else 4497 TYPE_FIELDS (type) = NULL_TREE; 4498 4499 TYPE_METHODS (type) = NULL_TREE; 4500 if (TYPE_BINFO (type)) 4501 free_lang_data_in_binfo (TYPE_BINFO (type)); 4502 } 4503 else 4504 { 4505 /* For non-aggregate types, clear out the language slot (which 4506 overloads TYPE_BINFO). */ 4507 TYPE_LANG_SLOT_1 (type) = NULL_TREE; 4508 4509 if (INTEGRAL_TYPE_P (type) 4510 || SCALAR_FLOAT_TYPE_P (type) 4511 || FIXED_POINT_TYPE_P (type)) 4512 { 4513 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type)); 4514 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type)); 4515 } 4516 } 4517 4518 free_lang_data_in_one_sizepos (&TYPE_SIZE (type)); 4519 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type)); 4520 4521 if (TYPE_CONTEXT (type) 4522 && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK) 4523 { 4524 tree ctx = TYPE_CONTEXT (type); 4525 do 4526 { 4527 ctx = BLOCK_SUPERCONTEXT (ctx); 4528 } 4529 while (ctx && TREE_CODE (ctx) == BLOCK); 4530 TYPE_CONTEXT (type) = ctx; 4531 } 4532 } 4533 4534 4535 /* Return true if DECL may need an assembler name to be set. */ 4536 4537 static inline bool 4538 need_assembler_name_p (tree decl) 4539 { 4540 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */ 4541 if (TREE_CODE (decl) != FUNCTION_DECL 4542 && TREE_CODE (decl) != VAR_DECL) 4543 return false; 4544 4545 /* If DECL already has its assembler name set, it does not need a 4546 new one. */ 4547 if (!HAS_DECL_ASSEMBLER_NAME_P (decl) 4548 || DECL_ASSEMBLER_NAME_SET_P (decl)) 4549 return false; 4550 4551 /* Abstract decls do not need an assembler name. */ 4552 if (DECL_ABSTRACT (decl)) 4553 return false; 4554 4555 /* For VAR_DECLs, only static, public and external symbols need an 4556 assembler name. */ 4557 if (TREE_CODE (decl) == VAR_DECL 4558 && !TREE_STATIC (decl) 4559 && !TREE_PUBLIC (decl) 4560 && !DECL_EXTERNAL (decl)) 4561 return false; 4562 4563 if (TREE_CODE (decl) == FUNCTION_DECL) 4564 { 4565 /* Do not set assembler name on builtins. Allow RTL expansion to 4566 decide whether to expand inline or via a regular call. */ 4567 if (DECL_BUILT_IN (decl) 4568 && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND) 4569 return false; 4570 4571 /* Functions represented in the callgraph need an assembler name. */ 4572 if (cgraph_get_node (decl) != NULL) 4573 return true; 4574 4575 /* Unused and not public functions don't need an assembler name. */ 4576 if (!TREE_USED (decl) && !TREE_PUBLIC (decl)) 4577 return false; 4578 } 4579 4580 return true; 4581 } 4582 4583 4584 /* Reset all language specific information still present in symbol 4585 DECL. */ 4586 4587 static void 4588 free_lang_data_in_decl (tree decl) 4589 { 4590 gcc_assert (DECL_P (decl)); 4591 4592 /* Give the FE a chance to remove its own data first. */ 4593 lang_hooks.free_lang_data (decl); 4594 4595 TREE_LANG_FLAG_0 (decl) = 0; 4596 TREE_LANG_FLAG_1 (decl) = 0; 4597 TREE_LANG_FLAG_2 (decl) = 0; 4598 TREE_LANG_FLAG_3 (decl) = 0; 4599 TREE_LANG_FLAG_4 (decl) = 0; 4600 TREE_LANG_FLAG_5 (decl) = 0; 4601 TREE_LANG_FLAG_6 (decl) = 0; 4602 4603 free_lang_data_in_one_sizepos (&DECL_SIZE (decl)); 4604 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl)); 4605 if (TREE_CODE (decl) == FIELD_DECL) 4606 { 4607 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl)); 4608 if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE) 4609 DECL_QUALIFIER (decl) = NULL_TREE; 4610 } 4611 4612 if (TREE_CODE (decl) == FUNCTION_DECL) 4613 { 4614 if (gimple_has_body_p (decl)) 4615 { 4616 tree t; 4617 4618 /* If DECL has a gimple body, then the context for its 4619 arguments must be DECL. Otherwise, it doesn't really 4620 matter, as we will not be emitting any code for DECL. In 4621 general, there may be other instances of DECL created by 4622 the front end and since PARM_DECLs are generally shared, 4623 their DECL_CONTEXT changes as the replicas of DECL are 4624 created. The only time where DECL_CONTEXT is important 4625 is for the FUNCTION_DECLs that have a gimple body (since 4626 the PARM_DECL will be used in the function's body). */ 4627 for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t)) 4628 DECL_CONTEXT (t) = decl; 4629 } 4630 4631 /* DECL_SAVED_TREE holds the GENERIC representation for DECL. 4632 At this point, it is not needed anymore. */ 4633 DECL_SAVED_TREE (decl) = NULL_TREE; 4634 4635 /* Clear the abstract origin if it refers to a method. Otherwise 4636 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the 4637 origin will not be output correctly. */ 4638 if (DECL_ABSTRACT_ORIGIN (decl) 4639 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl)) 4640 && RECORD_OR_UNION_TYPE_P 4641 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl)))) 4642 DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE; 4643 4644 /* Sometimes the C++ frontend doesn't manage to transform a temporary 4645 DECL_VINDEX referring to itself into a vtable slot number as it 4646 should. Happens with functions that are copied and then forgotten 4647 about. Just clear it, it won't matter anymore. */ 4648 if (DECL_VINDEX (decl) && !host_integerp (DECL_VINDEX (decl), 0)) 4649 DECL_VINDEX (decl) = NULL_TREE; 4650 } 4651 else if (TREE_CODE (decl) == VAR_DECL) 4652 { 4653 if ((DECL_EXTERNAL (decl) 4654 && (!TREE_STATIC (decl) || !TREE_READONLY (decl))) 4655 || (decl_function_context (decl) && !TREE_STATIC (decl))) 4656 DECL_INITIAL (decl) = NULL_TREE; 4657 } 4658 else if (TREE_CODE (decl) == TYPE_DECL 4659 || TREE_CODE (decl) == FIELD_DECL) 4660 DECL_INITIAL (decl) = NULL_TREE; 4661 else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL 4662 && DECL_INITIAL (decl) 4663 && TREE_CODE (DECL_INITIAL (decl)) == BLOCK) 4664 { 4665 /* Strip builtins from the translation-unit BLOCK. We still have targets 4666 without builtin_decl_explicit support and also builtins are shared 4667 nodes and thus we can't use TREE_CHAIN in multiple lists. */ 4668 tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl)); 4669 while (*nextp) 4670 { 4671 tree var = *nextp; 4672 if (TREE_CODE (var) == FUNCTION_DECL 4673 && DECL_BUILT_IN (var)) 4674 *nextp = TREE_CHAIN (var); 4675 else 4676 nextp = &TREE_CHAIN (var); 4677 } 4678 } 4679 } 4680 4681 4682 /* Data used when collecting DECLs and TYPEs for language data removal. */ 4683 4684 struct free_lang_data_d 4685 { 4686 /* Worklist to avoid excessive recursion. */ 4687 VEC(tree,heap) *worklist; 4688 4689 /* Set of traversed objects. Used to avoid duplicate visits. */ 4690 struct pointer_set_t *pset; 4691 4692 /* Array of symbols to process with free_lang_data_in_decl. */ 4693 VEC(tree,heap) *decls; 4694 4695 /* Array of types to process with free_lang_data_in_type. */ 4696 VEC(tree,heap) *types; 4697 }; 4698 4699 4700 /* Save all language fields needed to generate proper debug information 4701 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */ 4702 4703 static void 4704 save_debug_info_for_decl (tree t) 4705 { 4706 /*struct saved_debug_info_d *sdi;*/ 4707 4708 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t)); 4709 4710 /* FIXME. Partial implementation for saving debug info removed. */ 4711 } 4712 4713 4714 /* Save all language fields needed to generate proper debug information 4715 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */ 4716 4717 static void 4718 save_debug_info_for_type (tree t) 4719 { 4720 /*struct saved_debug_info_d *sdi;*/ 4721 4722 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t)); 4723 4724 /* FIXME. Partial implementation for saving debug info removed. */ 4725 } 4726 4727 4728 /* Add type or decl T to one of the list of tree nodes that need their 4729 language data removed. The lists are held inside FLD. */ 4730 4731 static void 4732 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld) 4733 { 4734 if (DECL_P (t)) 4735 { 4736 VEC_safe_push (tree, heap, fld->decls, t); 4737 if (debug_info_level > DINFO_LEVEL_TERSE) 4738 save_debug_info_for_decl (t); 4739 } 4740 else if (TYPE_P (t)) 4741 { 4742 VEC_safe_push (tree, heap, fld->types, t); 4743 if (debug_info_level > DINFO_LEVEL_TERSE) 4744 save_debug_info_for_type (t); 4745 } 4746 else 4747 gcc_unreachable (); 4748 } 4749 4750 /* Push tree node T into FLD->WORKLIST. */ 4751 4752 static inline void 4753 fld_worklist_push (tree t, struct free_lang_data_d *fld) 4754 { 4755 if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t)) 4756 VEC_safe_push (tree, heap, fld->worklist, (t)); 4757 } 4758 4759 4760 /* Operand callback helper for free_lang_data_in_node. *TP is the 4761 subtree operand being considered. */ 4762 4763 static tree 4764 find_decls_types_r (tree *tp, int *ws, void *data) 4765 { 4766 tree t = *tp; 4767 struct free_lang_data_d *fld = (struct free_lang_data_d *) data; 4768 4769 if (TREE_CODE (t) == TREE_LIST) 4770 return NULL_TREE; 4771 4772 /* Language specific nodes will be removed, so there is no need 4773 to gather anything under them. */ 4774 if (is_lang_specific (t)) 4775 { 4776 *ws = 0; 4777 return NULL_TREE; 4778 } 4779 4780 if (DECL_P (t)) 4781 { 4782 /* Note that walk_tree does not traverse every possible field in 4783 decls, so we have to do our own traversals here. */ 4784 add_tree_to_fld_list (t, fld); 4785 4786 fld_worklist_push (DECL_NAME (t), fld); 4787 fld_worklist_push (DECL_CONTEXT (t), fld); 4788 fld_worklist_push (DECL_SIZE (t), fld); 4789 fld_worklist_push (DECL_SIZE_UNIT (t), fld); 4790 4791 /* We are going to remove everything under DECL_INITIAL for 4792 TYPE_DECLs. No point walking them. */ 4793 if (TREE_CODE (t) != TYPE_DECL) 4794 fld_worklist_push (DECL_INITIAL (t), fld); 4795 4796 fld_worklist_push (DECL_ATTRIBUTES (t), fld); 4797 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld); 4798 4799 if (TREE_CODE (t) == FUNCTION_DECL) 4800 { 4801 fld_worklist_push (DECL_ARGUMENTS (t), fld); 4802 fld_worklist_push (DECL_RESULT (t), fld); 4803 } 4804 else if (TREE_CODE (t) == TYPE_DECL) 4805 { 4806 fld_worklist_push (DECL_ARGUMENT_FLD (t), fld); 4807 fld_worklist_push (DECL_VINDEX (t), fld); 4808 fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld); 4809 } 4810 else if (TREE_CODE (t) == FIELD_DECL) 4811 { 4812 fld_worklist_push (DECL_FIELD_OFFSET (t), fld); 4813 fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld); 4814 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld); 4815 fld_worklist_push (DECL_FCONTEXT (t), fld); 4816 } 4817 else if (TREE_CODE (t) == VAR_DECL) 4818 { 4819 fld_worklist_push (DECL_SECTION_NAME (t), fld); 4820 fld_worklist_push (DECL_COMDAT_GROUP (t), fld); 4821 } 4822 4823 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL) 4824 && DECL_HAS_VALUE_EXPR_P (t)) 4825 fld_worklist_push (DECL_VALUE_EXPR (t), fld); 4826 4827 if (TREE_CODE (t) != FIELD_DECL 4828 && TREE_CODE (t) != TYPE_DECL) 4829 fld_worklist_push (TREE_CHAIN (t), fld); 4830 *ws = 0; 4831 } 4832 else if (TYPE_P (t)) 4833 { 4834 /* Note that walk_tree does not traverse every possible field in 4835 types, so we have to do our own traversals here. */ 4836 add_tree_to_fld_list (t, fld); 4837 4838 if (!RECORD_OR_UNION_TYPE_P (t)) 4839 fld_worklist_push (TYPE_CACHED_VALUES (t), fld); 4840 fld_worklist_push (TYPE_SIZE (t), fld); 4841 fld_worklist_push (TYPE_SIZE_UNIT (t), fld); 4842 fld_worklist_push (TYPE_ATTRIBUTES (t), fld); 4843 fld_worklist_push (TYPE_POINTER_TO (t), fld); 4844 fld_worklist_push (TYPE_REFERENCE_TO (t), fld); 4845 fld_worklist_push (TYPE_NAME (t), fld); 4846 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream 4847 them and thus do not and want not to reach unused pointer types 4848 this way. */ 4849 if (!POINTER_TYPE_P (t)) 4850 fld_worklist_push (TYPE_MINVAL (t), fld); 4851 if (!RECORD_OR_UNION_TYPE_P (t)) 4852 fld_worklist_push (TYPE_MAXVAL (t), fld); 4853 fld_worklist_push (TYPE_MAIN_VARIANT (t), fld); 4854 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus 4855 do not and want not to reach unused variants this way. */ 4856 if (TYPE_CONTEXT (t)) 4857 { 4858 tree ctx = TYPE_CONTEXT (t); 4859 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one. 4860 So push that instead. */ 4861 while (ctx && TREE_CODE (ctx) == BLOCK) 4862 ctx = BLOCK_SUPERCONTEXT (ctx); 4863 fld_worklist_push (ctx, fld); 4864 } 4865 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not 4866 and want not to reach unused types this way. */ 4867 4868 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t)) 4869 { 4870 unsigned i; 4871 tree tem; 4872 for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)), 4873 i, tem); ++i) 4874 fld_worklist_push (TREE_TYPE (tem), fld); 4875 tem = BINFO_VIRTUALS (TYPE_BINFO (t)); 4876 if (tem 4877 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */ 4878 && TREE_CODE (tem) == TREE_LIST) 4879 do 4880 { 4881 fld_worklist_push (TREE_VALUE (tem), fld); 4882 tem = TREE_CHAIN (tem); 4883 } 4884 while (tem); 4885 } 4886 if (RECORD_OR_UNION_TYPE_P (t)) 4887 { 4888 tree tem; 4889 /* Push all TYPE_FIELDS - there can be interleaving interesting 4890 and non-interesting things. */ 4891 tem = TYPE_FIELDS (t); 4892 while (tem) 4893 { 4894 if (TREE_CODE (tem) == FIELD_DECL 4895 || TREE_CODE (tem) == TYPE_DECL) 4896 fld_worklist_push (tem, fld); 4897 tem = TREE_CHAIN (tem); 4898 } 4899 } 4900 4901 fld_worklist_push (TYPE_STUB_DECL (t), fld); 4902 *ws = 0; 4903 } 4904 else if (TREE_CODE (t) == BLOCK) 4905 { 4906 tree tem; 4907 for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem)) 4908 fld_worklist_push (tem, fld); 4909 for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem)) 4910 fld_worklist_push (tem, fld); 4911 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld); 4912 } 4913 4914 if (TREE_CODE (t) != IDENTIFIER_NODE 4915 && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED)) 4916 fld_worklist_push (TREE_TYPE (t), fld); 4917 4918 return NULL_TREE; 4919 } 4920 4921 4922 /* Find decls and types in T. */ 4923 4924 static void 4925 find_decls_types (tree t, struct free_lang_data_d *fld) 4926 { 4927 while (1) 4928 { 4929 if (!pointer_set_contains (fld->pset, t)) 4930 walk_tree (&t, find_decls_types_r, fld, fld->pset); 4931 if (VEC_empty (tree, fld->worklist)) 4932 break; 4933 t = VEC_pop (tree, fld->worklist); 4934 } 4935 } 4936 4937 /* Translate all the types in LIST with the corresponding runtime 4938 types. */ 4939 4940 static tree 4941 get_eh_types_for_runtime (tree list) 4942 { 4943 tree head, prev; 4944 4945 if (list == NULL_TREE) 4946 return NULL_TREE; 4947 4948 head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list))); 4949 prev = head; 4950 list = TREE_CHAIN (list); 4951 while (list) 4952 { 4953 tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list))); 4954 TREE_CHAIN (prev) = n; 4955 prev = TREE_CHAIN (prev); 4956 list = TREE_CHAIN (list); 4957 } 4958 4959 return head; 4960 } 4961 4962 4963 /* Find decls and types referenced in EH region R and store them in 4964 FLD->DECLS and FLD->TYPES. */ 4965 4966 static void 4967 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld) 4968 { 4969 switch (r->type) 4970 { 4971 case ERT_CLEANUP: 4972 break; 4973 4974 case ERT_TRY: 4975 { 4976 eh_catch c; 4977 4978 /* The types referenced in each catch must first be changed to the 4979 EH types used at runtime. This removes references to FE types 4980 in the region. */ 4981 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) 4982 { 4983 c->type_list = get_eh_types_for_runtime (c->type_list); 4984 walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset); 4985 } 4986 } 4987 break; 4988 4989 case ERT_ALLOWED_EXCEPTIONS: 4990 r->u.allowed.type_list 4991 = get_eh_types_for_runtime (r->u.allowed.type_list); 4992 walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset); 4993 break; 4994 4995 case ERT_MUST_NOT_THROW: 4996 walk_tree (&r->u.must_not_throw.failure_decl, 4997 find_decls_types_r, fld, fld->pset); 4998 break; 4999 } 5000 } 5001 5002 5003 /* Find decls and types referenced in cgraph node N and store them in 5004 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will 5005 look for *every* kind of DECL and TYPE node reachable from N, 5006 including those embedded inside types and decls (i.e,, TYPE_DECLs, 5007 NAMESPACE_DECLs, etc). */ 5008 5009 static void 5010 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld) 5011 { 5012 basic_block bb; 5013 struct function *fn; 5014 unsigned ix; 5015 tree t; 5016 5017 find_decls_types (n->decl, fld); 5018 5019 if (!gimple_has_body_p (n->decl)) 5020 return; 5021 5022 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL); 5023 5024 fn = DECL_STRUCT_FUNCTION (n->decl); 5025 5026 /* Traverse locals. */ 5027 FOR_EACH_LOCAL_DECL (fn, ix, t) 5028 find_decls_types (t, fld); 5029 5030 /* Traverse EH regions in FN. */ 5031 { 5032 eh_region r; 5033 FOR_ALL_EH_REGION_FN (r, fn) 5034 find_decls_types_in_eh_region (r, fld); 5035 } 5036 5037 /* Traverse every statement in FN. */ 5038 FOR_EACH_BB_FN (bb, fn) 5039 { 5040 gimple_stmt_iterator si; 5041 unsigned i; 5042 5043 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) 5044 { 5045 gimple phi = gsi_stmt (si); 5046 5047 for (i = 0; i < gimple_phi_num_args (phi); i++) 5048 { 5049 tree *arg_p = gimple_phi_arg_def_ptr (phi, i); 5050 find_decls_types (*arg_p, fld); 5051 } 5052 } 5053 5054 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) 5055 { 5056 gimple stmt = gsi_stmt (si); 5057 5058 if (is_gimple_call (stmt)) 5059 find_decls_types (gimple_call_fntype (stmt), fld); 5060 5061 for (i = 0; i < gimple_num_ops (stmt); i++) 5062 { 5063 tree arg = gimple_op (stmt, i); 5064 find_decls_types (arg, fld); 5065 } 5066 } 5067 } 5068 } 5069 5070 5071 /* Find decls and types referenced in varpool node N and store them in 5072 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will 5073 look for *every* kind of DECL and TYPE node reachable from N, 5074 including those embedded inside types and decls (i.e,, TYPE_DECLs, 5075 NAMESPACE_DECLs, etc). */ 5076 5077 static void 5078 find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld) 5079 { 5080 find_decls_types (v->decl, fld); 5081 } 5082 5083 /* If T needs an assembler name, have one created for it. */ 5084 5085 void 5086 assign_assembler_name_if_neeeded (tree t) 5087 { 5088 if (need_assembler_name_p (t)) 5089 { 5090 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit 5091 diagnostics that use input_location to show locus 5092 information. The problem here is that, at this point, 5093 input_location is generally anchored to the end of the file 5094 (since the parser is long gone), so we don't have a good 5095 position to pin it to. 5096 5097 To alleviate this problem, this uses the location of T's 5098 declaration. Examples of this are 5099 testsuite/g++.dg/template/cond2.C and 5100 testsuite/g++.dg/template/pr35240.C. */ 5101 location_t saved_location = input_location; 5102 input_location = DECL_SOURCE_LOCATION (t); 5103 5104 decl_assembler_name (t); 5105 5106 input_location = saved_location; 5107 } 5108 } 5109 5110 5111 /* Free language specific information for every operand and expression 5112 in every node of the call graph. This process operates in three stages: 5113 5114 1- Every callgraph node and varpool node is traversed looking for 5115 decls and types embedded in them. This is a more exhaustive 5116 search than that done by find_referenced_vars, because it will 5117 also collect individual fields, decls embedded in types, etc. 5118 5119 2- All the decls found are sent to free_lang_data_in_decl. 5120 5121 3- All the types found are sent to free_lang_data_in_type. 5122 5123 The ordering between decls and types is important because 5124 free_lang_data_in_decl sets assembler names, which includes 5125 mangling. So types cannot be freed up until assembler names have 5126 been set up. */ 5127 5128 static void 5129 free_lang_data_in_cgraph (void) 5130 { 5131 struct cgraph_node *n; 5132 struct varpool_node *v; 5133 struct free_lang_data_d fld; 5134 tree t; 5135 unsigned i; 5136 alias_pair *p; 5137 5138 /* Initialize sets and arrays to store referenced decls and types. */ 5139 fld.pset = pointer_set_create (); 5140 fld.worklist = NULL; 5141 fld.decls = VEC_alloc (tree, heap, 100); 5142 fld.types = VEC_alloc (tree, heap, 100); 5143 5144 /* Find decls and types in the body of every function in the callgraph. */ 5145 for (n = cgraph_nodes; n; n = n->next) 5146 find_decls_types_in_node (n, &fld); 5147 5148 FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p) 5149 find_decls_types (p->decl, &fld); 5150 5151 /* Find decls and types in every varpool symbol. */ 5152 for (v = varpool_nodes; v; v = v->next) 5153 find_decls_types_in_var (v, &fld); 5154 5155 /* Set the assembler name on every decl found. We need to do this 5156 now because free_lang_data_in_decl will invalidate data needed 5157 for mangling. This breaks mangling on interdependent decls. */ 5158 FOR_EACH_VEC_ELT (tree, fld.decls, i, t) 5159 assign_assembler_name_if_neeeded (t); 5160 5161 /* Traverse every decl found freeing its language data. */ 5162 FOR_EACH_VEC_ELT (tree, fld.decls, i, t) 5163 free_lang_data_in_decl (t); 5164 5165 /* Traverse every type found freeing its language data. */ 5166 FOR_EACH_VEC_ELT (tree, fld.types, i, t) 5167 free_lang_data_in_type (t); 5168 5169 pointer_set_destroy (fld.pset); 5170 VEC_free (tree, heap, fld.worklist); 5171 VEC_free (tree, heap, fld.decls); 5172 VEC_free (tree, heap, fld.types); 5173 } 5174 5175 5176 /* Free resources that are used by FE but are not needed once they are done. */ 5177 5178 static unsigned 5179 free_lang_data (void) 5180 { 5181 unsigned i; 5182 5183 /* If we are the LTO frontend we have freed lang-specific data already. */ 5184 if (in_lto_p 5185 || !flag_generate_lto) 5186 return 0; 5187 5188 /* Allocate and assign alias sets to the standard integer types 5189 while the slots are still in the way the frontends generated them. */ 5190 for (i = 0; i < itk_none; ++i) 5191 if (integer_types[i]) 5192 TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]); 5193 5194 /* Traverse the IL resetting language specific information for 5195 operands, expressions, etc. */ 5196 free_lang_data_in_cgraph (); 5197 5198 /* Create gimple variants for common types. */ 5199 ptrdiff_type_node = integer_type_node; 5200 fileptr_type_node = ptr_type_node; 5201 5202 /* Reset some langhooks. Do not reset types_compatible_p, it may 5203 still be used indirectly via the get_alias_set langhook. */ 5204 lang_hooks.callgraph.analyze_expr = NULL; 5205 lang_hooks.dwarf_name = lhd_dwarf_name; 5206 lang_hooks.decl_printable_name = gimple_decl_printable_name; 5207 /* We do not want the default decl_assembler_name implementation, 5208 rather if we have fixed everything we want a wrapper around it 5209 asserting that all non-local symbols already got their assembler 5210 name and only produce assembler names for local symbols. Or rather 5211 make sure we never call decl_assembler_name on local symbols and 5212 devise a separate, middle-end private scheme for it. */ 5213 5214 /* Reset diagnostic machinery. */ 5215 diagnostic_starter (global_dc) = default_tree_diagnostic_starter; 5216 diagnostic_finalizer (global_dc) = default_diagnostic_finalizer; 5217 diagnostic_format_decoder (global_dc) = default_tree_printer; 5218 5219 return 0; 5220 } 5221 5222 5223 struct simple_ipa_opt_pass pass_ipa_free_lang_data = 5224 { 5225 { 5226 SIMPLE_IPA_PASS, 5227 "*free_lang_data", /* name */ 5228 NULL, /* gate */ 5229 free_lang_data, /* execute */ 5230 NULL, /* sub */ 5231 NULL, /* next */ 5232 0, /* static_pass_number */ 5233 TV_IPA_FREE_LANG_DATA, /* tv_id */ 5234 0, /* properties_required */ 5235 0, /* properties_provided */ 5236 0, /* properties_destroyed */ 5237 0, /* todo_flags_start */ 5238 TODO_ggc_collect /* todo_flags_finish */ 5239 } 5240 }; 5241 5242 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of 5243 ATTR_NAME. Also used internally by remove_attribute(). */ 5244 bool 5245 private_is_attribute_p (const char *attr_name, size_t attr_len, const_tree ident) 5246 { 5247 size_t ident_len = IDENTIFIER_LENGTH (ident); 5248 5249 if (ident_len == attr_len) 5250 { 5251 if (strcmp (attr_name, IDENTIFIER_POINTER (ident)) == 0) 5252 return true; 5253 } 5254 else if (ident_len == attr_len + 4) 5255 { 5256 /* There is the possibility that ATTR is 'text' and IDENT is 5257 '__text__'. */ 5258 const char *p = IDENTIFIER_POINTER (ident); 5259 if (p[0] == '_' && p[1] == '_' 5260 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_' 5261 && strncmp (attr_name, p + 2, attr_len) == 0) 5262 return true; 5263 } 5264 5265 return false; 5266 } 5267 5268 /* The backbone of lookup_attribute(). ATTR_LEN is the string length 5269 of ATTR_NAME, and LIST is not NULL_TREE. */ 5270 tree 5271 private_lookup_attribute (const char *attr_name, size_t attr_len, tree list) 5272 { 5273 while (list) 5274 { 5275 size_t ident_len = IDENTIFIER_LENGTH (TREE_PURPOSE (list)); 5276 5277 if (ident_len == attr_len) 5278 { 5279 if (strcmp (attr_name, IDENTIFIER_POINTER (TREE_PURPOSE (list))) == 0) 5280 break; 5281 } 5282 /* TODO: If we made sure that attributes were stored in the 5283 canonical form without '__...__' (ie, as in 'text' as opposed 5284 to '__text__') then we could avoid the following case. */ 5285 else if (ident_len == attr_len + 4) 5286 { 5287 const char *p = IDENTIFIER_POINTER (TREE_PURPOSE (list)); 5288 if (p[0] == '_' && p[1] == '_' 5289 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_' 5290 && strncmp (attr_name, p + 2, attr_len) == 0) 5291 break; 5292 } 5293 list = TREE_CHAIN (list); 5294 } 5295 5296 return list; 5297 } 5298 5299 /* A variant of lookup_attribute() that can be used with an identifier 5300 as the first argument, and where the identifier can be either 5301 'text' or '__text__'. 5302 5303 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST, 5304 return a pointer to the attribute's list element if the attribute 5305 is part of the list, or NULL_TREE if not found. If the attribute 5306 appears more than once, this only returns the first occurrence; the 5307 TREE_CHAIN of the return value should be passed back in if further 5308 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but 5309 can be in the form 'text' or '__text__'. */ 5310 static tree 5311 lookup_ident_attribute (tree attr_identifier, tree list) 5312 { 5313 gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE); 5314 5315 while (list) 5316 { 5317 gcc_checking_assert (TREE_CODE (TREE_PURPOSE (list)) == IDENTIFIER_NODE); 5318 5319 /* Identifiers can be compared directly for equality. */ 5320 if (attr_identifier == TREE_PURPOSE (list)) 5321 break; 5322 5323 /* If they are not equal, they may still be one in the form 5324 'text' while the other one is in the form '__text__'. TODO: 5325 If we were storing attributes in normalized 'text' form, then 5326 this could all go away and we could take full advantage of 5327 the fact that we're comparing identifiers. :-) */ 5328 { 5329 size_t attr_len = IDENTIFIER_LENGTH (attr_identifier); 5330 size_t ident_len = IDENTIFIER_LENGTH (TREE_PURPOSE (list)); 5331 5332 if (ident_len == attr_len + 4) 5333 { 5334 const char *p = IDENTIFIER_POINTER (TREE_PURPOSE (list)); 5335 const char *q = IDENTIFIER_POINTER (attr_identifier); 5336 if (p[0] == '_' && p[1] == '_' 5337 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_' 5338 && strncmp (q, p + 2, attr_len) == 0) 5339 break; 5340 } 5341 else if (ident_len + 4 == attr_len) 5342 { 5343 const char *p = IDENTIFIER_POINTER (TREE_PURPOSE (list)); 5344 const char *q = IDENTIFIER_POINTER (attr_identifier); 5345 if (q[0] == '_' && q[1] == '_' 5346 && q[attr_len - 2] == '_' && q[attr_len - 1] == '_' 5347 && strncmp (q + 2, p, ident_len) == 0) 5348 break; 5349 } 5350 } 5351 list = TREE_CHAIN (list); 5352 } 5353 5354 return list; 5355 } 5356 5357 /* Remove any instances of attribute ATTR_NAME in LIST and return the 5358 modified list. */ 5359 5360 tree 5361 remove_attribute (const char *attr_name, tree list) 5362 { 5363 tree *p; 5364 size_t attr_len = strlen (attr_name); 5365 5366 gcc_checking_assert (attr_name[0] != '_'); 5367 5368 for (p = &list; *p; ) 5369 { 5370 tree l = *p; 5371 /* TODO: If we were storing attributes in normalized form, here 5372 we could use a simple strcmp(). */ 5373 if (private_is_attribute_p (attr_name, attr_len, TREE_PURPOSE (l))) 5374 *p = TREE_CHAIN (l); 5375 else 5376 p = &TREE_CHAIN (l); 5377 } 5378 5379 return list; 5380 } 5381 5382 /* Return an attribute list that is the union of a1 and a2. */ 5383 5384 tree 5385 merge_attributes (tree a1, tree a2) 5386 { 5387 tree attributes; 5388 5389 /* Either one unset? Take the set one. */ 5390 5391 if ((attributes = a1) == 0) 5392 attributes = a2; 5393 5394 /* One that completely contains the other? Take it. */ 5395 5396 else if (a2 != 0 && ! attribute_list_contained (a1, a2)) 5397 { 5398 if (attribute_list_contained (a2, a1)) 5399 attributes = a2; 5400 else 5401 { 5402 /* Pick the longest list, and hang on the other list. */ 5403 5404 if (list_length (a1) < list_length (a2)) 5405 attributes = a2, a2 = a1; 5406 5407 for (; a2 != 0; a2 = TREE_CHAIN (a2)) 5408 { 5409 tree a; 5410 for (a = lookup_ident_attribute (TREE_PURPOSE (a2), attributes); 5411 a != NULL_TREE && !attribute_value_equal (a, a2); 5412 a = lookup_ident_attribute (TREE_PURPOSE (a2), TREE_CHAIN (a))) 5413 ; 5414 if (a == NULL_TREE) 5415 { 5416 a1 = copy_node (a2); 5417 TREE_CHAIN (a1) = attributes; 5418 attributes = a1; 5419 } 5420 } 5421 } 5422 } 5423 return attributes; 5424 } 5425 5426 /* Given types T1 and T2, merge their attributes and return 5427 the result. */ 5428 5429 tree 5430 merge_type_attributes (tree t1, tree t2) 5431 { 5432 return merge_attributes (TYPE_ATTRIBUTES (t1), 5433 TYPE_ATTRIBUTES (t2)); 5434 } 5435 5436 /* Given decls OLDDECL and NEWDECL, merge their attributes and return 5437 the result. */ 5438 5439 tree 5440 merge_decl_attributes (tree olddecl, tree newdecl) 5441 { 5442 return merge_attributes (DECL_ATTRIBUTES (olddecl), 5443 DECL_ATTRIBUTES (newdecl)); 5444 } 5445 5446 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES 5447 5448 /* Specialization of merge_decl_attributes for various Windows targets. 5449 5450 This handles the following situation: 5451 5452 __declspec (dllimport) int foo; 5453 int foo; 5454 5455 The second instance of `foo' nullifies the dllimport. */ 5456 5457 tree 5458 merge_dllimport_decl_attributes (tree old, tree new_tree) 5459 { 5460 tree a; 5461 int delete_dllimport_p = 1; 5462 5463 /* What we need to do here is remove from `old' dllimport if it doesn't 5464 appear in `new'. dllimport behaves like extern: if a declaration is 5465 marked dllimport and a definition appears later, then the object 5466 is not dllimport'd. We also remove a `new' dllimport if the old list 5467 contains dllexport: dllexport always overrides dllimport, regardless 5468 of the order of declaration. */ 5469 if (!VAR_OR_FUNCTION_DECL_P (new_tree)) 5470 delete_dllimport_p = 0; 5471 else if (DECL_DLLIMPORT_P (new_tree) 5472 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old))) 5473 { 5474 DECL_DLLIMPORT_P (new_tree) = 0; 5475 warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: " 5476 "dllimport ignored", new_tree); 5477 } 5478 else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree)) 5479 { 5480 /* Warn about overriding a symbol that has already been used, e.g.: 5481 extern int __attribute__ ((dllimport)) foo; 5482 int* bar () {return &foo;} 5483 int foo; 5484 */ 5485 if (TREE_USED (old)) 5486 { 5487 warning (0, "%q+D redeclared without dllimport attribute " 5488 "after being referenced with dll linkage", new_tree); 5489 /* If we have used a variable's address with dllimport linkage, 5490 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the 5491 decl may already have had TREE_CONSTANT computed. 5492 We still remove the attribute so that assembler code refers 5493 to '&foo rather than '_imp__foo'. */ 5494 if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old)) 5495 DECL_DLLIMPORT_P (new_tree) = 1; 5496 } 5497 5498 /* Let an inline definition silently override the external reference, 5499 but otherwise warn about attribute inconsistency. */ 5500 else if (TREE_CODE (new_tree) == VAR_DECL 5501 || !DECL_DECLARED_INLINE_P (new_tree)) 5502 warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: " 5503 "previous dllimport ignored", new_tree); 5504 } 5505 else 5506 delete_dllimport_p = 0; 5507 5508 a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree)); 5509 5510 if (delete_dllimport_p) 5511 a = remove_attribute ("dllimport", a); 5512 5513 return a; 5514 } 5515 5516 /* Handle a "dllimport" or "dllexport" attribute; arguments as in 5517 struct attribute_spec.handler. */ 5518 5519 tree 5520 handle_dll_attribute (tree * pnode, tree name, tree args, int flags, 5521 bool *no_add_attrs) 5522 { 5523 tree node = *pnode; 5524 bool is_dllimport; 5525 5526 /* These attributes may apply to structure and union types being created, 5527 but otherwise should pass to the declaration involved. */ 5528 if (!DECL_P (node)) 5529 { 5530 if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT 5531 | (int) ATTR_FLAG_ARRAY_NEXT)) 5532 { 5533 *no_add_attrs = true; 5534 return tree_cons (name, args, NULL_TREE); 5535 } 5536 if (TREE_CODE (node) == RECORD_TYPE 5537 || TREE_CODE (node) == UNION_TYPE) 5538 { 5539 node = TYPE_NAME (node); 5540 if (!node) 5541 return NULL_TREE; 5542 } 5543 else 5544 { 5545 warning (OPT_Wattributes, "%qE attribute ignored", 5546 name); 5547 *no_add_attrs = true; 5548 return NULL_TREE; 5549 } 5550 } 5551 5552 if (TREE_CODE (node) != FUNCTION_DECL 5553 && TREE_CODE (node) != VAR_DECL 5554 && TREE_CODE (node) != TYPE_DECL) 5555 { 5556 *no_add_attrs = true; 5557 warning (OPT_Wattributes, "%qE attribute ignored", 5558 name); 5559 return NULL_TREE; 5560 } 5561 5562 if (TREE_CODE (node) == TYPE_DECL 5563 && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE 5564 && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE) 5565 { 5566 *no_add_attrs = true; 5567 warning (OPT_Wattributes, "%qE attribute ignored", 5568 name); 5569 return NULL_TREE; 5570 } 5571 5572 is_dllimport = is_attribute_p ("dllimport", name); 5573 5574 /* Report error on dllimport ambiguities seen now before they cause 5575 any damage. */ 5576 if (is_dllimport) 5577 { 5578 /* Honor any target-specific overrides. */ 5579 if (!targetm.valid_dllimport_attribute_p (node)) 5580 *no_add_attrs = true; 5581 5582 else if (TREE_CODE (node) == FUNCTION_DECL 5583 && DECL_DECLARED_INLINE_P (node)) 5584 { 5585 warning (OPT_Wattributes, "inline function %q+D declared as " 5586 " dllimport: attribute ignored", node); 5587 *no_add_attrs = true; 5588 } 5589 /* Like MS, treat definition of dllimported variables and 5590 non-inlined functions on declaration as syntax errors. */ 5591 else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node)) 5592 { 5593 error ("function %q+D definition is marked dllimport", node); 5594 *no_add_attrs = true; 5595 } 5596 5597 else if (TREE_CODE (node) == VAR_DECL) 5598 { 5599 if (DECL_INITIAL (node)) 5600 { 5601 error ("variable %q+D definition is marked dllimport", 5602 node); 5603 *no_add_attrs = true; 5604 } 5605 5606 /* `extern' needn't be specified with dllimport. 5607 Specify `extern' now and hope for the best. Sigh. */ 5608 DECL_EXTERNAL (node) = 1; 5609 /* Also, implicitly give dllimport'd variables declared within 5610 a function global scope, unless declared static. */ 5611 if (current_function_decl != NULL_TREE && !TREE_STATIC (node)) 5612 TREE_PUBLIC (node) = 1; 5613 } 5614 5615 if (*no_add_attrs == false) 5616 DECL_DLLIMPORT_P (node) = 1; 5617 } 5618 else if (TREE_CODE (node) == FUNCTION_DECL 5619 && DECL_DECLARED_INLINE_P (node) 5620 && flag_keep_inline_dllexport) 5621 /* An exported function, even if inline, must be emitted. */ 5622 DECL_EXTERNAL (node) = 0; 5623 5624 /* Report error if symbol is not accessible at global scope. */ 5625 if (!TREE_PUBLIC (node) 5626 && (TREE_CODE (node) == VAR_DECL 5627 || TREE_CODE (node) == FUNCTION_DECL)) 5628 { 5629 error ("external linkage required for symbol %q+D because of " 5630 "%qE attribute", node, name); 5631 *no_add_attrs = true; 5632 } 5633 5634 /* A dllexport'd entity must have default visibility so that other 5635 program units (shared libraries or the main executable) can see 5636 it. A dllimport'd entity must have default visibility so that 5637 the linker knows that undefined references within this program 5638 unit can be resolved by the dynamic linker. */ 5639 if (!*no_add_attrs) 5640 { 5641 if (DECL_VISIBILITY_SPECIFIED (node) 5642 && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT) 5643 error ("%qE implies default visibility, but %qD has already " 5644 "been declared with a different visibility", 5645 name, node); 5646 DECL_VISIBILITY (node) = VISIBILITY_DEFAULT; 5647 DECL_VISIBILITY_SPECIFIED (node) = 1; 5648 } 5649 5650 return NULL_TREE; 5651 } 5652 5653 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */ 5654 5655 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask 5656 of the various TYPE_QUAL values. */ 5657 5658 static void 5659 set_type_quals (tree type, int type_quals) 5660 { 5661 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0; 5662 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0; 5663 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0; 5664 TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals); 5665 } 5666 5667 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */ 5668 5669 bool 5670 check_qualified_type (const_tree cand, const_tree base, int type_quals) 5671 { 5672 return (TYPE_QUALS (cand) == type_quals 5673 && TYPE_NAME (cand) == TYPE_NAME (base) 5674 /* Apparently this is needed for Objective-C. */ 5675 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base) 5676 /* Check alignment. */ 5677 && TYPE_ALIGN (cand) == TYPE_ALIGN (base) 5678 && attribute_list_equal (TYPE_ATTRIBUTES (cand), 5679 TYPE_ATTRIBUTES (base))); 5680 } 5681 5682 /* Returns true iff CAND is equivalent to BASE with ALIGN. */ 5683 5684 static bool 5685 check_aligned_type (const_tree cand, const_tree base, unsigned int align) 5686 { 5687 return (TYPE_QUALS (cand) == TYPE_QUALS (base) 5688 && TYPE_NAME (cand) == TYPE_NAME (base) 5689 /* Apparently this is needed for Objective-C. */ 5690 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base) 5691 /* Check alignment. */ 5692 && TYPE_ALIGN (cand) == align 5693 && attribute_list_equal (TYPE_ATTRIBUTES (cand), 5694 TYPE_ATTRIBUTES (base))); 5695 } 5696 5697 /* Return a version of the TYPE, qualified as indicated by the 5698 TYPE_QUALS, if one exists. If no qualified version exists yet, 5699 return NULL_TREE. */ 5700 5701 tree 5702 get_qualified_type (tree type, int type_quals) 5703 { 5704 tree t; 5705 5706 if (TYPE_QUALS (type) == type_quals) 5707 return type; 5708 5709 /* Search the chain of variants to see if there is already one there just 5710 like the one we need to have. If so, use that existing one. We must 5711 preserve the TYPE_NAME, since there is code that depends on this. */ 5712 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 5713 if (check_qualified_type (t, type, type_quals)) 5714 return t; 5715 5716 return NULL_TREE; 5717 } 5718 5719 /* Like get_qualified_type, but creates the type if it does not 5720 exist. This function never returns NULL_TREE. */ 5721 5722 tree 5723 build_qualified_type (tree type, int type_quals) 5724 { 5725 tree t; 5726 5727 /* See if we already have the appropriate qualified variant. */ 5728 t = get_qualified_type (type, type_quals); 5729 5730 /* If not, build it. */ 5731 if (!t) 5732 { 5733 t = build_variant_type_copy (type); 5734 set_type_quals (t, type_quals); 5735 5736 if (TYPE_STRUCTURAL_EQUALITY_P (type)) 5737 /* Propagate structural equality. */ 5738 SET_TYPE_STRUCTURAL_EQUALITY (t); 5739 else if (TYPE_CANONICAL (type) != type) 5740 /* Build the underlying canonical type, since it is different 5741 from TYPE. */ 5742 TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type), 5743 type_quals); 5744 else 5745 /* T is its own canonical type. */ 5746 TYPE_CANONICAL (t) = t; 5747 5748 } 5749 5750 return t; 5751 } 5752 5753 /* Create a variant of type T with alignment ALIGN. */ 5754 5755 tree 5756 build_aligned_type (tree type, unsigned int align) 5757 { 5758 tree t; 5759 5760 if (TYPE_PACKED (type) 5761 || TYPE_ALIGN (type) == align) 5762 return type; 5763 5764 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 5765 if (check_aligned_type (t, type, align)) 5766 return t; 5767 5768 t = build_variant_type_copy (type); 5769 TYPE_ALIGN (t) = align; 5770 5771 return t; 5772 } 5773 5774 /* Create a new distinct copy of TYPE. The new type is made its own 5775 MAIN_VARIANT. If TYPE requires structural equality checks, the 5776 resulting type requires structural equality checks; otherwise, its 5777 TYPE_CANONICAL points to itself. */ 5778 5779 tree 5780 build_distinct_type_copy (tree type) 5781 { 5782 tree t = copy_node (type); 5783 5784 TYPE_POINTER_TO (t) = 0; 5785 TYPE_REFERENCE_TO (t) = 0; 5786 5787 /* Set the canonical type either to a new equivalence class, or 5788 propagate the need for structural equality checks. */ 5789 if (TYPE_STRUCTURAL_EQUALITY_P (type)) 5790 SET_TYPE_STRUCTURAL_EQUALITY (t); 5791 else 5792 TYPE_CANONICAL (t) = t; 5793 5794 /* Make it its own variant. */ 5795 TYPE_MAIN_VARIANT (t) = t; 5796 TYPE_NEXT_VARIANT (t) = 0; 5797 5798 /* Note that it is now possible for TYPE_MIN_VALUE to be a value 5799 whose TREE_TYPE is not t. This can also happen in the Ada 5800 frontend when using subtypes. */ 5801 5802 return t; 5803 } 5804 5805 /* Create a new variant of TYPE, equivalent but distinct. This is so 5806 the caller can modify it. TYPE_CANONICAL for the return type will 5807 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types 5808 are considered equal by the language itself (or that both types 5809 require structural equality checks). */ 5810 5811 tree 5812 build_variant_type_copy (tree type) 5813 { 5814 tree t, m = TYPE_MAIN_VARIANT (type); 5815 5816 t = build_distinct_type_copy (type); 5817 5818 /* Since we're building a variant, assume that it is a non-semantic 5819 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */ 5820 TYPE_CANONICAL (t) = TYPE_CANONICAL (type); 5821 5822 /* Add the new type to the chain of variants of TYPE. */ 5823 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m); 5824 TYPE_NEXT_VARIANT (m) = t; 5825 TYPE_MAIN_VARIANT (t) = m; 5826 5827 return t; 5828 } 5829 5830 /* Return true if the from tree in both tree maps are equal. */ 5831 5832 int 5833 tree_map_base_eq (const void *va, const void *vb) 5834 { 5835 const struct tree_map_base *const a = (const struct tree_map_base *) va, 5836 *const b = (const struct tree_map_base *) vb; 5837 return (a->from == b->from); 5838 } 5839 5840 /* Hash a from tree in a tree_base_map. */ 5841 5842 unsigned int 5843 tree_map_base_hash (const void *item) 5844 { 5845 return htab_hash_pointer (((const struct tree_map_base *)item)->from); 5846 } 5847 5848 /* Return true if this tree map structure is marked for garbage collection 5849 purposes. We simply return true if the from tree is marked, so that this 5850 structure goes away when the from tree goes away. */ 5851 5852 int 5853 tree_map_base_marked_p (const void *p) 5854 { 5855 return ggc_marked_p (((const struct tree_map_base *) p)->from); 5856 } 5857 5858 /* Hash a from tree in a tree_map. */ 5859 5860 unsigned int 5861 tree_map_hash (const void *item) 5862 { 5863 return (((const struct tree_map *) item)->hash); 5864 } 5865 5866 /* Hash a from tree in a tree_decl_map. */ 5867 5868 unsigned int 5869 tree_decl_map_hash (const void *item) 5870 { 5871 return DECL_UID (((const struct tree_decl_map *) item)->base.from); 5872 } 5873 5874 /* Return the initialization priority for DECL. */ 5875 5876 priority_type 5877 decl_init_priority_lookup (tree decl) 5878 { 5879 struct tree_priority_map *h; 5880 struct tree_map_base in; 5881 5882 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); 5883 in.from = decl; 5884 h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in); 5885 return h ? h->init : DEFAULT_INIT_PRIORITY; 5886 } 5887 5888 /* Return the finalization priority for DECL. */ 5889 5890 priority_type 5891 decl_fini_priority_lookup (tree decl) 5892 { 5893 struct tree_priority_map *h; 5894 struct tree_map_base in; 5895 5896 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 5897 in.from = decl; 5898 h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in); 5899 return h ? h->fini : DEFAULT_INIT_PRIORITY; 5900 } 5901 5902 /* Return the initialization and finalization priority information for 5903 DECL. If there is no previous priority information, a freshly 5904 allocated structure is returned. */ 5905 5906 static struct tree_priority_map * 5907 decl_priority_info (tree decl) 5908 { 5909 struct tree_priority_map in; 5910 struct tree_priority_map *h; 5911 void **loc; 5912 5913 in.base.from = decl; 5914 loc = htab_find_slot (init_priority_for_decl, &in, INSERT); 5915 h = (struct tree_priority_map *) *loc; 5916 if (!h) 5917 { 5918 h = ggc_alloc_cleared_tree_priority_map (); 5919 *loc = h; 5920 h->base.from = decl; 5921 h->init = DEFAULT_INIT_PRIORITY; 5922 h->fini = DEFAULT_INIT_PRIORITY; 5923 } 5924 5925 return h; 5926 } 5927 5928 /* Set the initialization priority for DECL to PRIORITY. */ 5929 5930 void 5931 decl_init_priority_insert (tree decl, priority_type priority) 5932 { 5933 struct tree_priority_map *h; 5934 5935 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); 5936 if (priority == DEFAULT_INIT_PRIORITY) 5937 return; 5938 h = decl_priority_info (decl); 5939 h->init = priority; 5940 } 5941 5942 /* Set the finalization priority for DECL to PRIORITY. */ 5943 5944 void 5945 decl_fini_priority_insert (tree decl, priority_type priority) 5946 { 5947 struct tree_priority_map *h; 5948 5949 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 5950 if (priority == DEFAULT_INIT_PRIORITY) 5951 return; 5952 h = decl_priority_info (decl); 5953 h->fini = priority; 5954 } 5955 5956 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */ 5957 5958 static void 5959 print_debug_expr_statistics (void) 5960 { 5961 fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n", 5962 (long) htab_size (debug_expr_for_decl), 5963 (long) htab_elements (debug_expr_for_decl), 5964 htab_collisions (debug_expr_for_decl)); 5965 } 5966 5967 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */ 5968 5969 static void 5970 print_value_expr_statistics (void) 5971 { 5972 fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n", 5973 (long) htab_size (value_expr_for_decl), 5974 (long) htab_elements (value_expr_for_decl), 5975 htab_collisions (value_expr_for_decl)); 5976 } 5977 5978 /* Lookup a debug expression for FROM, and return it if we find one. */ 5979 5980 tree 5981 decl_debug_expr_lookup (tree from) 5982 { 5983 struct tree_decl_map *h, in; 5984 in.base.from = from; 5985 5986 h = (struct tree_decl_map *) 5987 htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from)); 5988 if (h) 5989 return h->to; 5990 return NULL_TREE; 5991 } 5992 5993 /* Insert a mapping FROM->TO in the debug expression hashtable. */ 5994 5995 void 5996 decl_debug_expr_insert (tree from, tree to) 5997 { 5998 struct tree_decl_map *h; 5999 void **loc; 6000 6001 h = ggc_alloc_tree_decl_map (); 6002 h->base.from = from; 6003 h->to = to; 6004 loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from), 6005 INSERT); 6006 *(struct tree_decl_map **) loc = h; 6007 } 6008 6009 /* Lookup a value expression for FROM, and return it if we find one. */ 6010 6011 tree 6012 decl_value_expr_lookup (tree from) 6013 { 6014 struct tree_decl_map *h, in; 6015 in.base.from = from; 6016 6017 h = (struct tree_decl_map *) 6018 htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from)); 6019 if (h) 6020 return h->to; 6021 return NULL_TREE; 6022 } 6023 6024 /* Insert a mapping FROM->TO in the value expression hashtable. */ 6025 6026 void 6027 decl_value_expr_insert (tree from, tree to) 6028 { 6029 struct tree_decl_map *h; 6030 void **loc; 6031 6032 h = ggc_alloc_tree_decl_map (); 6033 h->base.from = from; 6034 h->to = to; 6035 loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from), 6036 INSERT); 6037 *(struct tree_decl_map **) loc = h; 6038 } 6039 6040 /* Lookup a vector of debug arguments for FROM, and return it if we 6041 find one. */ 6042 6043 VEC(tree, gc) ** 6044 decl_debug_args_lookup (tree from) 6045 { 6046 struct tree_vec_map *h, in; 6047 6048 if (!DECL_HAS_DEBUG_ARGS_P (from)) 6049 return NULL; 6050 gcc_checking_assert (debug_args_for_decl != NULL); 6051 in.base.from = from; 6052 h = (struct tree_vec_map *) 6053 htab_find_with_hash (debug_args_for_decl, &in, DECL_UID (from)); 6054 if (h) 6055 return &h->to; 6056 return NULL; 6057 } 6058 6059 /* Insert a mapping FROM->empty vector of debug arguments in the value 6060 expression hashtable. */ 6061 6062 VEC(tree, gc) ** 6063 decl_debug_args_insert (tree from) 6064 { 6065 struct tree_vec_map *h; 6066 void **loc; 6067 6068 if (DECL_HAS_DEBUG_ARGS_P (from)) 6069 return decl_debug_args_lookup (from); 6070 if (debug_args_for_decl == NULL) 6071 debug_args_for_decl = htab_create_ggc (64, tree_vec_map_hash, 6072 tree_vec_map_eq, 0); 6073 h = ggc_alloc_tree_vec_map (); 6074 h->base.from = from; 6075 h->to = NULL; 6076 loc = htab_find_slot_with_hash (debug_args_for_decl, h, DECL_UID (from), 6077 INSERT); 6078 *(struct tree_vec_map **) loc = h; 6079 DECL_HAS_DEBUG_ARGS_P (from) = 1; 6080 return &h->to; 6081 } 6082 6083 /* Hashing of types so that we don't make duplicates. 6084 The entry point is `type_hash_canon'. */ 6085 6086 /* Compute a hash code for a list of types (chain of TREE_LIST nodes 6087 with types in the TREE_VALUE slots), by adding the hash codes 6088 of the individual types. */ 6089 6090 static unsigned int 6091 type_hash_list (const_tree list, hashval_t hashcode) 6092 { 6093 const_tree tail; 6094 6095 for (tail = list; tail; tail = TREE_CHAIN (tail)) 6096 if (TREE_VALUE (tail) != error_mark_node) 6097 hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)), 6098 hashcode); 6099 6100 return hashcode; 6101 } 6102 6103 /* These are the Hashtable callback functions. */ 6104 6105 /* Returns true iff the types are equivalent. */ 6106 6107 static int 6108 type_hash_eq (const void *va, const void *vb) 6109 { 6110 const struct type_hash *const a = (const struct type_hash *) va, 6111 *const b = (const struct type_hash *) vb; 6112 6113 /* First test the things that are the same for all types. */ 6114 if (a->hash != b->hash 6115 || TREE_CODE (a->type) != TREE_CODE (b->type) 6116 || TREE_TYPE (a->type) != TREE_TYPE (b->type) 6117 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type), 6118 TYPE_ATTRIBUTES (b->type)) 6119 || (TREE_CODE (a->type) != COMPLEX_TYPE 6120 && TYPE_NAME (a->type) != TYPE_NAME (b->type))) 6121 return 0; 6122 6123 /* Be careful about comparing arrays before and after the element type 6124 has been completed; don't compare TYPE_ALIGN unless both types are 6125 complete. */ 6126 if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type) 6127 && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type) 6128 || TYPE_MODE (a->type) != TYPE_MODE (b->type))) 6129 return 0; 6130 6131 switch (TREE_CODE (a->type)) 6132 { 6133 case VOID_TYPE: 6134 case COMPLEX_TYPE: 6135 case POINTER_TYPE: 6136 case REFERENCE_TYPE: 6137 case NULLPTR_TYPE: 6138 return 1; 6139 6140 case VECTOR_TYPE: 6141 return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type); 6142 6143 case ENUMERAL_TYPE: 6144 if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type) 6145 && !(TYPE_VALUES (a->type) 6146 && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST 6147 && TYPE_VALUES (b->type) 6148 && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST 6149 && type_list_equal (TYPE_VALUES (a->type), 6150 TYPE_VALUES (b->type)))) 6151 return 0; 6152 6153 /* ... fall through ... */ 6154 6155 case INTEGER_TYPE: 6156 case REAL_TYPE: 6157 case BOOLEAN_TYPE: 6158 return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type) 6159 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type), 6160 TYPE_MAX_VALUE (b->type))) 6161 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type) 6162 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type), 6163 TYPE_MIN_VALUE (b->type)))); 6164 6165 case FIXED_POINT_TYPE: 6166 return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type); 6167 6168 case OFFSET_TYPE: 6169 return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type); 6170 6171 case METHOD_TYPE: 6172 if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type) 6173 && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type) 6174 || (TYPE_ARG_TYPES (a->type) 6175 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST 6176 && TYPE_ARG_TYPES (b->type) 6177 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST 6178 && type_list_equal (TYPE_ARG_TYPES (a->type), 6179 TYPE_ARG_TYPES (b->type))))) 6180 break; 6181 return 0; 6182 case ARRAY_TYPE: 6183 return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type); 6184 6185 case RECORD_TYPE: 6186 case UNION_TYPE: 6187 case QUAL_UNION_TYPE: 6188 return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type) 6189 || (TYPE_FIELDS (a->type) 6190 && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST 6191 && TYPE_FIELDS (b->type) 6192 && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST 6193 && type_list_equal (TYPE_FIELDS (a->type), 6194 TYPE_FIELDS (b->type)))); 6195 6196 case FUNCTION_TYPE: 6197 if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type) 6198 || (TYPE_ARG_TYPES (a->type) 6199 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST 6200 && TYPE_ARG_TYPES (b->type) 6201 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST 6202 && type_list_equal (TYPE_ARG_TYPES (a->type), 6203 TYPE_ARG_TYPES (b->type)))) 6204 break; 6205 return 0; 6206 6207 default: 6208 return 0; 6209 } 6210 6211 if (lang_hooks.types.type_hash_eq != NULL) 6212 return lang_hooks.types.type_hash_eq (a->type, b->type); 6213 6214 return 1; 6215 } 6216 6217 /* Return the cached hash value. */ 6218 6219 static hashval_t 6220 type_hash_hash (const void *item) 6221 { 6222 return ((const struct type_hash *) item)->hash; 6223 } 6224 6225 /* Look in the type hash table for a type isomorphic to TYPE. 6226 If one is found, return it. Otherwise return 0. */ 6227 6228 tree 6229 type_hash_lookup (hashval_t hashcode, tree type) 6230 { 6231 struct type_hash *h, in; 6232 6233 /* The TYPE_ALIGN field of a type is set by layout_type(), so we 6234 must call that routine before comparing TYPE_ALIGNs. */ 6235 layout_type (type); 6236 6237 in.hash = hashcode; 6238 in.type = type; 6239 6240 h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in, 6241 hashcode); 6242 if (h) 6243 return h->type; 6244 return NULL_TREE; 6245 } 6246 6247 /* Add an entry to the type-hash-table 6248 for a type TYPE whose hash code is HASHCODE. */ 6249 6250 void 6251 type_hash_add (hashval_t hashcode, tree type) 6252 { 6253 struct type_hash *h; 6254 void **loc; 6255 6256 h = ggc_alloc_type_hash (); 6257 h->hash = hashcode; 6258 h->type = type; 6259 loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT); 6260 *loc = (void *)h; 6261 } 6262 6263 /* Given TYPE, and HASHCODE its hash code, return the canonical 6264 object for an identical type if one already exists. 6265 Otherwise, return TYPE, and record it as the canonical object. 6266 6267 To use this function, first create a type of the sort you want. 6268 Then compute its hash code from the fields of the type that 6269 make it different from other similar types. 6270 Then call this function and use the value. */ 6271 6272 tree 6273 type_hash_canon (unsigned int hashcode, tree type) 6274 { 6275 tree t1; 6276 6277 /* The hash table only contains main variants, so ensure that's what we're 6278 being passed. */ 6279 gcc_assert (TYPE_MAIN_VARIANT (type) == type); 6280 6281 /* See if the type is in the hash table already. If so, return it. 6282 Otherwise, add the type. */ 6283 t1 = type_hash_lookup (hashcode, type); 6284 if (t1 != 0) 6285 { 6286 #ifdef GATHER_STATISTICS 6287 tree_code_counts[(int) TREE_CODE (type)]--; 6288 tree_node_counts[(int) t_kind]--; 6289 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type_non_common); 6290 #endif 6291 return t1; 6292 } 6293 else 6294 { 6295 type_hash_add (hashcode, type); 6296 return type; 6297 } 6298 } 6299 6300 /* See if the data pointed to by the type hash table is marked. We consider 6301 it marked if the type is marked or if a debug type number or symbol 6302 table entry has been made for the type. */ 6303 6304 static int 6305 type_hash_marked_p (const void *p) 6306 { 6307 const_tree const type = ((const struct type_hash *) p)->type; 6308 6309 return ggc_marked_p (type); 6310 } 6311 6312 static void 6313 print_type_hash_statistics (void) 6314 { 6315 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n", 6316 (long) htab_size (type_hash_table), 6317 (long) htab_elements (type_hash_table), 6318 htab_collisions (type_hash_table)); 6319 } 6320 6321 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes 6322 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots), 6323 by adding the hash codes of the individual attributes. */ 6324 6325 static unsigned int 6326 attribute_hash_list (const_tree list, hashval_t hashcode) 6327 { 6328 const_tree tail; 6329 6330 for (tail = list; tail; tail = TREE_CHAIN (tail)) 6331 /* ??? Do we want to add in TREE_VALUE too? */ 6332 hashcode = iterative_hash_object 6333 (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode); 6334 return hashcode; 6335 } 6336 6337 /* Given two lists of attributes, return true if list l2 is 6338 equivalent to l1. */ 6339 6340 int 6341 attribute_list_equal (const_tree l1, const_tree l2) 6342 { 6343 if (l1 == l2) 6344 return 1; 6345 6346 return attribute_list_contained (l1, l2) 6347 && attribute_list_contained (l2, l1); 6348 } 6349 6350 /* Given two lists of attributes, return true if list L2 is 6351 completely contained within L1. */ 6352 /* ??? This would be faster if attribute names were stored in a canonicalized 6353 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method 6354 must be used to show these elements are equivalent (which they are). */ 6355 /* ??? It's not clear that attributes with arguments will always be handled 6356 correctly. */ 6357 6358 int 6359 attribute_list_contained (const_tree l1, const_tree l2) 6360 { 6361 const_tree t1, t2; 6362 6363 /* First check the obvious, maybe the lists are identical. */ 6364 if (l1 == l2) 6365 return 1; 6366 6367 /* Maybe the lists are similar. */ 6368 for (t1 = l1, t2 = l2; 6369 t1 != 0 && t2 != 0 6370 && TREE_PURPOSE (t1) == TREE_PURPOSE (t2) 6371 && TREE_VALUE (t1) == TREE_VALUE (t2); 6372 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) 6373 ; 6374 6375 /* Maybe the lists are equal. */ 6376 if (t1 == 0 && t2 == 0) 6377 return 1; 6378 6379 for (; t2 != 0; t2 = TREE_CHAIN (t2)) 6380 { 6381 const_tree attr; 6382 /* This CONST_CAST is okay because lookup_attribute does not 6383 modify its argument and the return value is assigned to a 6384 const_tree. */ 6385 for (attr = lookup_ident_attribute (TREE_PURPOSE (t2), CONST_CAST_TREE(l1)); 6386 attr != NULL_TREE && !attribute_value_equal (t2, attr); 6387 attr = lookup_ident_attribute (TREE_PURPOSE (t2), TREE_CHAIN (attr))) 6388 ; 6389 6390 if (attr == NULL_TREE) 6391 return 0; 6392 } 6393 6394 return 1; 6395 } 6396 6397 /* Given two lists of types 6398 (chains of TREE_LIST nodes with types in the TREE_VALUE slots) 6399 return 1 if the lists contain the same types in the same order. 6400 Also, the TREE_PURPOSEs must match. */ 6401 6402 int 6403 type_list_equal (const_tree l1, const_tree l2) 6404 { 6405 const_tree t1, t2; 6406 6407 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) 6408 if (TREE_VALUE (t1) != TREE_VALUE (t2) 6409 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2) 6410 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)) 6411 && (TREE_TYPE (TREE_PURPOSE (t1)) 6412 == TREE_TYPE (TREE_PURPOSE (t2)))))) 6413 return 0; 6414 6415 return t1 == t2; 6416 } 6417 6418 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE 6419 given by TYPE. If the argument list accepts variable arguments, 6420 then this function counts only the ordinary arguments. */ 6421 6422 int 6423 type_num_arguments (const_tree type) 6424 { 6425 int i = 0; 6426 tree t; 6427 6428 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t)) 6429 /* If the function does not take a variable number of arguments, 6430 the last element in the list will have type `void'. */ 6431 if (VOID_TYPE_P (TREE_VALUE (t))) 6432 break; 6433 else 6434 ++i; 6435 6436 return i; 6437 } 6438 6439 /* Nonzero if integer constants T1 and T2 6440 represent the same constant value. */ 6441 6442 int 6443 tree_int_cst_equal (const_tree t1, const_tree t2) 6444 { 6445 if (t1 == t2) 6446 return 1; 6447 6448 if (t1 == 0 || t2 == 0) 6449 return 0; 6450 6451 if (TREE_CODE (t1) == INTEGER_CST 6452 && TREE_CODE (t2) == INTEGER_CST 6453 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) 6454 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)) 6455 return 1; 6456 6457 return 0; 6458 } 6459 6460 /* Nonzero if integer constants T1 and T2 represent values that satisfy <. 6461 The precise way of comparison depends on their data type. */ 6462 6463 int 6464 tree_int_cst_lt (const_tree t1, const_tree t2) 6465 { 6466 if (t1 == t2) 6467 return 0; 6468 6469 if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2))) 6470 { 6471 int t1_sgn = tree_int_cst_sgn (t1); 6472 int t2_sgn = tree_int_cst_sgn (t2); 6473 6474 if (t1_sgn < t2_sgn) 6475 return 1; 6476 else if (t1_sgn > t2_sgn) 6477 return 0; 6478 /* Otherwise, both are non-negative, so we compare them as 6479 unsigned just in case one of them would overflow a signed 6480 type. */ 6481 } 6482 else if (!TYPE_UNSIGNED (TREE_TYPE (t1))) 6483 return INT_CST_LT (t1, t2); 6484 6485 return INT_CST_LT_UNSIGNED (t1, t2); 6486 } 6487 6488 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */ 6489 6490 int 6491 tree_int_cst_compare (const_tree t1, const_tree t2) 6492 { 6493 if (tree_int_cst_lt (t1, t2)) 6494 return -1; 6495 else if (tree_int_cst_lt (t2, t1)) 6496 return 1; 6497 else 6498 return 0; 6499 } 6500 6501 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on 6502 the host. If POS is zero, the value can be represented in a single 6503 HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can 6504 be represented in a single unsigned HOST_WIDE_INT. */ 6505 6506 int 6507 host_integerp (const_tree t, int pos) 6508 { 6509 if (t == NULL_TREE) 6510 return 0; 6511 6512 return (TREE_CODE (t) == INTEGER_CST 6513 && ((TREE_INT_CST_HIGH (t) == 0 6514 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0) 6515 || (! pos && TREE_INT_CST_HIGH (t) == -1 6516 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0 6517 && (!TYPE_UNSIGNED (TREE_TYPE (t)) 6518 || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE 6519 && TYPE_IS_SIZETYPE (TREE_TYPE (t))))) 6520 || (pos && TREE_INT_CST_HIGH (t) == 0))); 6521 } 6522 6523 /* Return the HOST_WIDE_INT least significant bits of T if it is an 6524 INTEGER_CST and there is no overflow. POS is nonzero if the result must 6525 be non-negative. We must be able to satisfy the above conditions. */ 6526 6527 HOST_WIDE_INT 6528 tree_low_cst (const_tree t, int pos) 6529 { 6530 gcc_assert (host_integerp (t, pos)); 6531 return TREE_INT_CST_LOW (t); 6532 } 6533 6534 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype 6535 kind INTEGER_CST. This makes sure to properly sign-extend the 6536 constant. */ 6537 6538 HOST_WIDE_INT 6539 size_low_cst (const_tree t) 6540 { 6541 double_int d = tree_to_double_int (t); 6542 return double_int_sext (d, TYPE_PRECISION (TREE_TYPE (t))).low; 6543 } 6544 6545 /* Return the most significant (sign) bit of T. */ 6546 6547 int 6548 tree_int_cst_sign_bit (const_tree t) 6549 { 6550 unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1; 6551 unsigned HOST_WIDE_INT w; 6552 6553 if (bitno < HOST_BITS_PER_WIDE_INT) 6554 w = TREE_INT_CST_LOW (t); 6555 else 6556 { 6557 w = TREE_INT_CST_HIGH (t); 6558 bitno -= HOST_BITS_PER_WIDE_INT; 6559 } 6560 6561 return (w >> bitno) & 1; 6562 } 6563 6564 /* Return an indication of the sign of the integer constant T. 6565 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0. 6566 Note that -1 will never be returned if T's type is unsigned. */ 6567 6568 int 6569 tree_int_cst_sgn (const_tree t) 6570 { 6571 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0) 6572 return 0; 6573 else if (TYPE_UNSIGNED (TREE_TYPE (t))) 6574 return 1; 6575 else if (TREE_INT_CST_HIGH (t) < 0) 6576 return -1; 6577 else 6578 return 1; 6579 } 6580 6581 /* Return the minimum number of bits needed to represent VALUE in a 6582 signed or unsigned type, UNSIGNEDP says which. */ 6583 6584 unsigned int 6585 tree_int_cst_min_precision (tree value, bool unsignedp) 6586 { 6587 int log; 6588 6589 /* If the value is negative, compute its negative minus 1. The latter 6590 adjustment is because the absolute value of the largest negative value 6591 is one larger than the largest positive value. This is equivalent to 6592 a bit-wise negation, so use that operation instead. */ 6593 6594 if (tree_int_cst_sgn (value) < 0) 6595 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value); 6596 6597 /* Return the number of bits needed, taking into account the fact 6598 that we need one more bit for a signed than unsigned type. */ 6599 6600 if (integer_zerop (value)) 6601 log = 0; 6602 else 6603 log = tree_floor_log2 (value); 6604 6605 return log + 1 + !unsignedp; 6606 } 6607 6608 /* Compare two constructor-element-type constants. Return 1 if the lists 6609 are known to be equal; otherwise return 0. */ 6610 6611 int 6612 simple_cst_list_equal (const_tree l1, const_tree l2) 6613 { 6614 while (l1 != NULL_TREE && l2 != NULL_TREE) 6615 { 6616 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1) 6617 return 0; 6618 6619 l1 = TREE_CHAIN (l1); 6620 l2 = TREE_CHAIN (l2); 6621 } 6622 6623 return l1 == l2; 6624 } 6625 6626 /* Return truthvalue of whether T1 is the same tree structure as T2. 6627 Return 1 if they are the same. 6628 Return 0 if they are understandably different. 6629 Return -1 if either contains tree structure not understood by 6630 this function. */ 6631 6632 int 6633 simple_cst_equal (const_tree t1, const_tree t2) 6634 { 6635 enum tree_code code1, code2; 6636 int cmp; 6637 int i; 6638 6639 if (t1 == t2) 6640 return 1; 6641 if (t1 == 0 || t2 == 0) 6642 return 0; 6643 6644 code1 = TREE_CODE (t1); 6645 code2 = TREE_CODE (t2); 6646 6647 if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR) 6648 { 6649 if (CONVERT_EXPR_CODE_P (code2) 6650 || code2 == NON_LVALUE_EXPR) 6651 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 6652 else 6653 return simple_cst_equal (TREE_OPERAND (t1, 0), t2); 6654 } 6655 6656 else if (CONVERT_EXPR_CODE_P (code2) 6657 || code2 == NON_LVALUE_EXPR) 6658 return simple_cst_equal (t1, TREE_OPERAND (t2, 0)); 6659 6660 if (code1 != code2) 6661 return 0; 6662 6663 switch (code1) 6664 { 6665 case INTEGER_CST: 6666 return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) 6667 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)); 6668 6669 case REAL_CST: 6670 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); 6671 6672 case FIXED_CST: 6673 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2)); 6674 6675 case STRING_CST: 6676 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) 6677 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), 6678 TREE_STRING_LENGTH (t1))); 6679 6680 case CONSTRUCTOR: 6681 { 6682 unsigned HOST_WIDE_INT idx; 6683 VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1); 6684 VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2); 6685 6686 if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2)) 6687 return false; 6688 6689 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) 6690 /* ??? Should we handle also fields here? */ 6691 if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value, 6692 VEC_index (constructor_elt, v2, idx)->value)) 6693 return false; 6694 return true; 6695 } 6696 6697 case SAVE_EXPR: 6698 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 6699 6700 case CALL_EXPR: 6701 cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)); 6702 if (cmp <= 0) 6703 return cmp; 6704 if (call_expr_nargs (t1) != call_expr_nargs (t2)) 6705 return 0; 6706 { 6707 const_tree arg1, arg2; 6708 const_call_expr_arg_iterator iter1, iter2; 6709 for (arg1 = first_const_call_expr_arg (t1, &iter1), 6710 arg2 = first_const_call_expr_arg (t2, &iter2); 6711 arg1 && arg2; 6712 arg1 = next_const_call_expr_arg (&iter1), 6713 arg2 = next_const_call_expr_arg (&iter2)) 6714 { 6715 cmp = simple_cst_equal (arg1, arg2); 6716 if (cmp <= 0) 6717 return cmp; 6718 } 6719 return arg1 == arg2; 6720 } 6721 6722 case TARGET_EXPR: 6723 /* Special case: if either target is an unallocated VAR_DECL, 6724 it means that it's going to be unified with whatever the 6725 TARGET_EXPR is really supposed to initialize, so treat it 6726 as being equivalent to anything. */ 6727 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL 6728 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE 6729 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0))) 6730 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL 6731 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE 6732 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0)))) 6733 cmp = 1; 6734 else 6735 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 6736 6737 if (cmp <= 0) 6738 return cmp; 6739 6740 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 6741 6742 case WITH_CLEANUP_EXPR: 6743 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 6744 if (cmp <= 0) 6745 return cmp; 6746 6747 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1)); 6748 6749 case COMPONENT_REF: 6750 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1)) 6751 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 6752 6753 return 0; 6754 6755 case VAR_DECL: 6756 case PARM_DECL: 6757 case CONST_DECL: 6758 case FUNCTION_DECL: 6759 return 0; 6760 6761 default: 6762 break; 6763 } 6764 6765 /* This general rule works for most tree codes. All exceptions should be 6766 handled above. If this is a language-specific tree code, we can't 6767 trust what might be in the operand, so say we don't know 6768 the situation. */ 6769 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE) 6770 return -1; 6771 6772 switch (TREE_CODE_CLASS (code1)) 6773 { 6774 case tcc_unary: 6775 case tcc_binary: 6776 case tcc_comparison: 6777 case tcc_expression: 6778 case tcc_reference: 6779 case tcc_statement: 6780 cmp = 1; 6781 for (i = 0; i < TREE_CODE_LENGTH (code1); i++) 6782 { 6783 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)); 6784 if (cmp <= 0) 6785 return cmp; 6786 } 6787 6788 return cmp; 6789 6790 default: 6791 return -1; 6792 } 6793 } 6794 6795 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value. 6796 Return -1, 0, or 1 if the value of T is less than, equal to, or greater 6797 than U, respectively. */ 6798 6799 int 6800 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u) 6801 { 6802 if (tree_int_cst_sgn (t) < 0) 6803 return -1; 6804 else if (TREE_INT_CST_HIGH (t) != 0) 6805 return 1; 6806 else if (TREE_INT_CST_LOW (t) == u) 6807 return 0; 6808 else if (TREE_INT_CST_LOW (t) < u) 6809 return -1; 6810 else 6811 return 1; 6812 } 6813 6814 /* Return true if CODE represents an associative tree code. Otherwise 6815 return false. */ 6816 bool 6817 associative_tree_code (enum tree_code code) 6818 { 6819 switch (code) 6820 { 6821 case BIT_IOR_EXPR: 6822 case BIT_AND_EXPR: 6823 case BIT_XOR_EXPR: 6824 case PLUS_EXPR: 6825 case MULT_EXPR: 6826 case MIN_EXPR: 6827 case MAX_EXPR: 6828 return true; 6829 6830 default: 6831 break; 6832 } 6833 return false; 6834 } 6835 6836 /* Return true if CODE represents a commutative tree code. Otherwise 6837 return false. */ 6838 bool 6839 commutative_tree_code (enum tree_code code) 6840 { 6841 switch (code) 6842 { 6843 case PLUS_EXPR: 6844 case MULT_EXPR: 6845 case MIN_EXPR: 6846 case MAX_EXPR: 6847 case BIT_IOR_EXPR: 6848 case BIT_XOR_EXPR: 6849 case BIT_AND_EXPR: 6850 case NE_EXPR: 6851 case EQ_EXPR: 6852 case UNORDERED_EXPR: 6853 case ORDERED_EXPR: 6854 case UNEQ_EXPR: 6855 case LTGT_EXPR: 6856 case TRUTH_AND_EXPR: 6857 case TRUTH_XOR_EXPR: 6858 case TRUTH_OR_EXPR: 6859 return true; 6860 6861 default: 6862 break; 6863 } 6864 return false; 6865 } 6866 6867 /* Return true if CODE represents a ternary tree code for which the 6868 first two operands are commutative. Otherwise return false. */ 6869 bool 6870 commutative_ternary_tree_code (enum tree_code code) 6871 { 6872 switch (code) 6873 { 6874 case WIDEN_MULT_PLUS_EXPR: 6875 case WIDEN_MULT_MINUS_EXPR: 6876 return true; 6877 6878 default: 6879 break; 6880 } 6881 return false; 6882 } 6883 6884 /* Generate a hash value for an expression. This can be used iteratively 6885 by passing a previous result as the VAL argument. 6886 6887 This function is intended to produce the same hash for expressions which 6888 would compare equal using operand_equal_p. */ 6889 6890 hashval_t 6891 iterative_hash_expr (const_tree t, hashval_t val) 6892 { 6893 int i; 6894 enum tree_code code; 6895 char tclass; 6896 6897 if (t == NULL_TREE) 6898 return iterative_hash_hashval_t (0, val); 6899 6900 code = TREE_CODE (t); 6901 6902 switch (code) 6903 { 6904 /* Alas, constants aren't shared, so we can't rely on pointer 6905 identity. */ 6906 case INTEGER_CST: 6907 val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val); 6908 return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val); 6909 case REAL_CST: 6910 { 6911 unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t)); 6912 6913 return iterative_hash_hashval_t (val2, val); 6914 } 6915 case FIXED_CST: 6916 { 6917 unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t)); 6918 6919 return iterative_hash_hashval_t (val2, val); 6920 } 6921 case STRING_CST: 6922 return iterative_hash (TREE_STRING_POINTER (t), 6923 TREE_STRING_LENGTH (t), val); 6924 case COMPLEX_CST: 6925 val = iterative_hash_expr (TREE_REALPART (t), val); 6926 return iterative_hash_expr (TREE_IMAGPART (t), val); 6927 case VECTOR_CST: 6928 return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val); 6929 case SSA_NAME: 6930 /* We can just compare by pointer. */ 6931 return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val); 6932 case PLACEHOLDER_EXPR: 6933 /* The node itself doesn't matter. */ 6934 return val; 6935 case TREE_LIST: 6936 /* A list of expressions, for a CALL_EXPR or as the elements of a 6937 VECTOR_CST. */ 6938 for (; t; t = TREE_CHAIN (t)) 6939 val = iterative_hash_expr (TREE_VALUE (t), val); 6940 return val; 6941 case CONSTRUCTOR: 6942 { 6943 unsigned HOST_WIDE_INT idx; 6944 tree field, value; 6945 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value) 6946 { 6947 val = iterative_hash_expr (field, val); 6948 val = iterative_hash_expr (value, val); 6949 } 6950 return val; 6951 } 6952 case MEM_REF: 6953 { 6954 /* The type of the second operand is relevant, except for 6955 its top-level qualifiers. */ 6956 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (t, 1))); 6957 6958 val = iterative_hash_object (TYPE_HASH (type), val); 6959 6960 /* We could use the standard hash computation from this point 6961 on. */ 6962 val = iterative_hash_object (code, val); 6963 val = iterative_hash_expr (TREE_OPERAND (t, 1), val); 6964 val = iterative_hash_expr (TREE_OPERAND (t, 0), val); 6965 return val; 6966 } 6967 case FUNCTION_DECL: 6968 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form. 6969 Otherwise nodes that compare equal according to operand_equal_p might 6970 get different hash codes. However, don't do this for machine specific 6971 or front end builtins, since the function code is overloaded in those 6972 cases. */ 6973 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL 6974 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t))) 6975 { 6976 t = builtin_decl_explicit (DECL_FUNCTION_CODE (t)); 6977 code = TREE_CODE (t); 6978 } 6979 /* FALL THROUGH */ 6980 default: 6981 tclass = TREE_CODE_CLASS (code); 6982 6983 if (tclass == tcc_declaration) 6984 { 6985 /* DECL's have a unique ID */ 6986 val = iterative_hash_host_wide_int (DECL_UID (t), val); 6987 } 6988 else 6989 { 6990 gcc_assert (IS_EXPR_CODE_CLASS (tclass)); 6991 6992 val = iterative_hash_object (code, val); 6993 6994 /* Don't hash the type, that can lead to having nodes which 6995 compare equal according to operand_equal_p, but which 6996 have different hash codes. */ 6997 if (CONVERT_EXPR_CODE_P (code) 6998 || code == NON_LVALUE_EXPR) 6999 { 7000 /* Make sure to include signness in the hash computation. */ 7001 val += TYPE_UNSIGNED (TREE_TYPE (t)); 7002 val = iterative_hash_expr (TREE_OPERAND (t, 0), val); 7003 } 7004 7005 else if (commutative_tree_code (code)) 7006 { 7007 /* It's a commutative expression. We want to hash it the same 7008 however it appears. We do this by first hashing both operands 7009 and then rehashing based on the order of their independent 7010 hashes. */ 7011 hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0); 7012 hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0); 7013 hashval_t t; 7014 7015 if (one > two) 7016 t = one, one = two, two = t; 7017 7018 val = iterative_hash_hashval_t (one, val); 7019 val = iterative_hash_hashval_t (two, val); 7020 } 7021 else 7022 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i) 7023 val = iterative_hash_expr (TREE_OPERAND (t, i), val); 7024 } 7025 return val; 7026 } 7027 } 7028 7029 /* Generate a hash value for a pair of expressions. This can be used 7030 iteratively by passing a previous result as the VAL argument. 7031 7032 The same hash value is always returned for a given pair of expressions, 7033 regardless of the order in which they are presented. This is useful in 7034 hashing the operands of commutative functions. */ 7035 7036 hashval_t 7037 iterative_hash_exprs_commutative (const_tree t1, 7038 const_tree t2, hashval_t val) 7039 { 7040 hashval_t one = iterative_hash_expr (t1, 0); 7041 hashval_t two = iterative_hash_expr (t2, 0); 7042 hashval_t t; 7043 7044 if (one > two) 7045 t = one, one = two, two = t; 7046 val = iterative_hash_hashval_t (one, val); 7047 val = iterative_hash_hashval_t (two, val); 7048 7049 return val; 7050 } 7051 7052 /* Constructors for pointer, array and function types. 7053 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are 7054 constructed by language-dependent code, not here.) */ 7055 7056 /* Construct, lay out and return the type of pointers to TO_TYPE with 7057 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can 7058 reference all of memory. If such a type has already been 7059 constructed, reuse it. */ 7060 7061 tree 7062 build_pointer_type_for_mode (tree to_type, enum machine_mode mode, 7063 bool can_alias_all) 7064 { 7065 tree t; 7066 7067 if (to_type == error_mark_node) 7068 return error_mark_node; 7069 7070 /* If the pointed-to type has the may_alias attribute set, force 7071 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */ 7072 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type))) 7073 can_alias_all = true; 7074 7075 /* In some cases, languages will have things that aren't a POINTER_TYPE 7076 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO. 7077 In that case, return that type without regard to the rest of our 7078 operands. 7079 7080 ??? This is a kludge, but consistent with the way this function has 7081 always operated and there doesn't seem to be a good way to avoid this 7082 at the moment. */ 7083 if (TYPE_POINTER_TO (to_type) != 0 7084 && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE) 7085 return TYPE_POINTER_TO (to_type); 7086 7087 /* First, if we already have a type for pointers to TO_TYPE and it's 7088 the proper mode, use it. */ 7089 for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t)) 7090 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all) 7091 return t; 7092 7093 t = make_node (POINTER_TYPE); 7094 7095 TREE_TYPE (t) = to_type; 7096 SET_TYPE_MODE (t, mode); 7097 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all; 7098 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type); 7099 TYPE_POINTER_TO (to_type) = t; 7100 7101 if (TYPE_STRUCTURAL_EQUALITY_P (to_type)) 7102 SET_TYPE_STRUCTURAL_EQUALITY (t); 7103 else if (TYPE_CANONICAL (to_type) != to_type) 7104 TYPE_CANONICAL (t) 7105 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type), 7106 mode, can_alias_all); 7107 7108 /* Lay out the type. This function has many callers that are concerned 7109 with expression-construction, and this simplifies them all. */ 7110 layout_type (t); 7111 7112 return t; 7113 } 7114 7115 /* By default build pointers in ptr_mode. */ 7116 7117 tree 7118 build_pointer_type (tree to_type) 7119 { 7120 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC 7121 : TYPE_ADDR_SPACE (to_type); 7122 enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as); 7123 return build_pointer_type_for_mode (to_type, pointer_mode, false); 7124 } 7125 7126 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */ 7127 7128 tree 7129 build_reference_type_for_mode (tree to_type, enum machine_mode mode, 7130 bool can_alias_all) 7131 { 7132 tree t; 7133 7134 if (to_type == error_mark_node) 7135 return error_mark_node; 7136 7137 /* If the pointed-to type has the may_alias attribute set, force 7138 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */ 7139 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type))) 7140 can_alias_all = true; 7141 7142 /* In some cases, languages will have things that aren't a REFERENCE_TYPE 7143 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO. 7144 In that case, return that type without regard to the rest of our 7145 operands. 7146 7147 ??? This is a kludge, but consistent with the way this function has 7148 always operated and there doesn't seem to be a good way to avoid this 7149 at the moment. */ 7150 if (TYPE_REFERENCE_TO (to_type) != 0 7151 && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE) 7152 return TYPE_REFERENCE_TO (to_type); 7153 7154 /* First, if we already have a type for pointers to TO_TYPE and it's 7155 the proper mode, use it. */ 7156 for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t)) 7157 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all) 7158 return t; 7159 7160 t = make_node (REFERENCE_TYPE); 7161 7162 TREE_TYPE (t) = to_type; 7163 SET_TYPE_MODE (t, mode); 7164 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all; 7165 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type); 7166 TYPE_REFERENCE_TO (to_type) = t; 7167 7168 if (TYPE_STRUCTURAL_EQUALITY_P (to_type)) 7169 SET_TYPE_STRUCTURAL_EQUALITY (t); 7170 else if (TYPE_CANONICAL (to_type) != to_type) 7171 TYPE_CANONICAL (t) 7172 = build_reference_type_for_mode (TYPE_CANONICAL (to_type), 7173 mode, can_alias_all); 7174 7175 layout_type (t); 7176 7177 return t; 7178 } 7179 7180 7181 /* Build the node for the type of references-to-TO_TYPE by default 7182 in ptr_mode. */ 7183 7184 tree 7185 build_reference_type (tree to_type) 7186 { 7187 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC 7188 : TYPE_ADDR_SPACE (to_type); 7189 enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as); 7190 return build_reference_type_for_mode (to_type, pointer_mode, false); 7191 } 7192 7193 /* Build a type that is compatible with t but has no cv quals anywhere 7194 in its type, thus 7195 7196 const char *const *const * -> char ***. */ 7197 7198 tree 7199 build_type_no_quals (tree t) 7200 { 7201 switch (TREE_CODE (t)) 7202 { 7203 case POINTER_TYPE: 7204 return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)), 7205 TYPE_MODE (t), 7206 TYPE_REF_CAN_ALIAS_ALL (t)); 7207 case REFERENCE_TYPE: 7208 return 7209 build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)), 7210 TYPE_MODE (t), 7211 TYPE_REF_CAN_ALIAS_ALL (t)); 7212 default: 7213 return TYPE_MAIN_VARIANT (t); 7214 } 7215 } 7216 7217 #define MAX_INT_CACHED_PREC \ 7218 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64) 7219 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2]; 7220 7221 /* Builds a signed or unsigned integer type of precision PRECISION. 7222 Used for C bitfields whose precision does not match that of 7223 built-in target types. */ 7224 tree 7225 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision, 7226 int unsignedp) 7227 { 7228 tree itype, ret; 7229 7230 if (unsignedp) 7231 unsignedp = MAX_INT_CACHED_PREC + 1; 7232 7233 if (precision <= MAX_INT_CACHED_PREC) 7234 { 7235 itype = nonstandard_integer_type_cache[precision + unsignedp]; 7236 if (itype) 7237 return itype; 7238 } 7239 7240 itype = make_node (INTEGER_TYPE); 7241 TYPE_PRECISION (itype) = precision; 7242 7243 if (unsignedp) 7244 fixup_unsigned_type (itype); 7245 else 7246 fixup_signed_type (itype); 7247 7248 ret = itype; 7249 if (host_integerp (TYPE_MAX_VALUE (itype), 1)) 7250 ret = type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype); 7251 if (precision <= MAX_INT_CACHED_PREC) 7252 nonstandard_integer_type_cache[precision + unsignedp] = ret; 7253 7254 return ret; 7255 } 7256 7257 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE 7258 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED 7259 is true, reuse such a type that has already been constructed. */ 7260 7261 static tree 7262 build_range_type_1 (tree type, tree lowval, tree highval, bool shared) 7263 { 7264 tree itype = make_node (INTEGER_TYPE); 7265 hashval_t hashcode = 0; 7266 7267 TREE_TYPE (itype) = type; 7268 7269 TYPE_MIN_VALUE (itype) = fold_convert (type, lowval); 7270 TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL; 7271 7272 TYPE_PRECISION (itype) = TYPE_PRECISION (type); 7273 SET_TYPE_MODE (itype, TYPE_MODE (type)); 7274 TYPE_SIZE (itype) = TYPE_SIZE (type); 7275 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type); 7276 TYPE_ALIGN (itype) = TYPE_ALIGN (type); 7277 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type); 7278 7279 if (!shared) 7280 return itype; 7281 7282 if ((TYPE_MIN_VALUE (itype) 7283 && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST) 7284 || (TYPE_MAX_VALUE (itype) 7285 && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST)) 7286 { 7287 /* Since we cannot reliably merge this type, we need to compare it using 7288 structural equality checks. */ 7289 SET_TYPE_STRUCTURAL_EQUALITY (itype); 7290 return itype; 7291 } 7292 7293 hashcode = iterative_hash_expr (TYPE_MIN_VALUE (itype), hashcode); 7294 hashcode = iterative_hash_expr (TYPE_MAX_VALUE (itype), hashcode); 7295 hashcode = iterative_hash_hashval_t (TYPE_HASH (type), hashcode); 7296 itype = type_hash_canon (hashcode, itype); 7297 7298 return itype; 7299 } 7300 7301 /* Wrapper around build_range_type_1 with SHARED set to true. */ 7302 7303 tree 7304 build_range_type (tree type, tree lowval, tree highval) 7305 { 7306 return build_range_type_1 (type, lowval, highval, true); 7307 } 7308 7309 /* Wrapper around build_range_type_1 with SHARED set to false. */ 7310 7311 tree 7312 build_nonshared_range_type (tree type, tree lowval, tree highval) 7313 { 7314 return build_range_type_1 (type, lowval, highval, false); 7315 } 7316 7317 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE. 7318 MAXVAL should be the maximum value in the domain 7319 (one less than the length of the array). 7320 7321 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT. 7322 We don't enforce this limit, that is up to caller (e.g. language front end). 7323 The limit exists because the result is a signed type and we don't handle 7324 sizes that use more than one HOST_WIDE_INT. */ 7325 7326 tree 7327 build_index_type (tree maxval) 7328 { 7329 return build_range_type (sizetype, size_zero_node, maxval); 7330 } 7331 7332 /* Return true if the debug information for TYPE, a subtype, should be emitted 7333 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the 7334 high bound, respectively. Sometimes doing so unnecessarily obfuscates the 7335 debug info and doesn't reflect the source code. */ 7336 7337 bool 7338 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval) 7339 { 7340 tree base_type = TREE_TYPE (type), low, high; 7341 7342 /* Subrange types have a base type which is an integral type. */ 7343 if (!INTEGRAL_TYPE_P (base_type)) 7344 return false; 7345 7346 /* Get the real bounds of the subtype. */ 7347 if (lang_hooks.types.get_subrange_bounds) 7348 lang_hooks.types.get_subrange_bounds (type, &low, &high); 7349 else 7350 { 7351 low = TYPE_MIN_VALUE (type); 7352 high = TYPE_MAX_VALUE (type); 7353 } 7354 7355 /* If the type and its base type have the same representation and the same 7356 name, then the type is not a subrange but a copy of the base type. */ 7357 if ((TREE_CODE (base_type) == INTEGER_TYPE 7358 || TREE_CODE (base_type) == BOOLEAN_TYPE) 7359 && int_size_in_bytes (type) == int_size_in_bytes (base_type) 7360 && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type)) 7361 && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))) 7362 { 7363 tree type_name = TYPE_NAME (type); 7364 tree base_type_name = TYPE_NAME (base_type); 7365 7366 if (type_name && TREE_CODE (type_name) == TYPE_DECL) 7367 type_name = DECL_NAME (type_name); 7368 7369 if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL) 7370 base_type_name = DECL_NAME (base_type_name); 7371 7372 if (type_name == base_type_name) 7373 return false; 7374 } 7375 7376 if (lowval) 7377 *lowval = low; 7378 if (highval) 7379 *highval = high; 7380 return true; 7381 } 7382 7383 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE 7384 and number of elements specified by the range of values of INDEX_TYPE. 7385 If SHARED is true, reuse such a type that has already been constructed. */ 7386 7387 static tree 7388 build_array_type_1 (tree elt_type, tree index_type, bool shared) 7389 { 7390 tree t; 7391 7392 if (TREE_CODE (elt_type) == FUNCTION_TYPE) 7393 { 7394 error ("arrays of functions are not meaningful"); 7395 elt_type = integer_type_node; 7396 } 7397 7398 t = make_node (ARRAY_TYPE); 7399 TREE_TYPE (t) = elt_type; 7400 TYPE_DOMAIN (t) = index_type; 7401 TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type); 7402 layout_type (t); 7403 7404 /* If the element type is incomplete at this point we get marked for 7405 structural equality. Do not record these types in the canonical 7406 type hashtable. */ 7407 if (TYPE_STRUCTURAL_EQUALITY_P (t)) 7408 return t; 7409 7410 if (shared) 7411 { 7412 hashval_t hashcode = iterative_hash_object (TYPE_HASH (elt_type), 0); 7413 if (index_type) 7414 hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode); 7415 t = type_hash_canon (hashcode, t); 7416 } 7417 7418 if (TYPE_CANONICAL (t) == t) 7419 { 7420 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type) 7421 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))) 7422 SET_TYPE_STRUCTURAL_EQUALITY (t); 7423 else if (TYPE_CANONICAL (elt_type) != elt_type 7424 || (index_type && TYPE_CANONICAL (index_type) != index_type)) 7425 TYPE_CANONICAL (t) 7426 = build_array_type_1 (TYPE_CANONICAL (elt_type), 7427 index_type 7428 ? TYPE_CANONICAL (index_type) : NULL_TREE, 7429 shared); 7430 } 7431 7432 return t; 7433 } 7434 7435 /* Wrapper around build_array_type_1 with SHARED set to true. */ 7436 7437 tree 7438 build_array_type (tree elt_type, tree index_type) 7439 { 7440 return build_array_type_1 (elt_type, index_type, true); 7441 } 7442 7443 /* Wrapper around build_array_type_1 with SHARED set to false. */ 7444 7445 tree 7446 build_nonshared_array_type (tree elt_type, tree index_type) 7447 { 7448 return build_array_type_1 (elt_type, index_type, false); 7449 } 7450 7451 /* Return a representation of ELT_TYPE[NELTS], using indices of type 7452 sizetype. */ 7453 7454 tree 7455 build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts) 7456 { 7457 return build_array_type (elt_type, build_index_type (size_int (nelts - 1))); 7458 } 7459 7460 /* Recursively examines the array elements of TYPE, until a non-array 7461 element type is found. */ 7462 7463 tree 7464 strip_array_types (tree type) 7465 { 7466 while (TREE_CODE (type) == ARRAY_TYPE) 7467 type = TREE_TYPE (type); 7468 7469 return type; 7470 } 7471 7472 /* Computes the canonical argument types from the argument type list 7473 ARGTYPES. 7474 7475 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true 7476 on entry to this function, or if any of the ARGTYPES are 7477 structural. 7478 7479 Upon return, *ANY_NONCANONICAL_P will be true iff either it was 7480 true on entry to this function, or if any of the ARGTYPES are 7481 non-canonical. 7482 7483 Returns a canonical argument list, which may be ARGTYPES when the 7484 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is 7485 true) or would not differ from ARGTYPES. */ 7486 7487 static tree 7488 maybe_canonicalize_argtypes(tree argtypes, 7489 bool *any_structural_p, 7490 bool *any_noncanonical_p) 7491 { 7492 tree arg; 7493 bool any_noncanonical_argtypes_p = false; 7494 7495 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg)) 7496 { 7497 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node) 7498 /* Fail gracefully by stating that the type is structural. */ 7499 *any_structural_p = true; 7500 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg))) 7501 *any_structural_p = true; 7502 else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg) 7503 || TREE_PURPOSE (arg)) 7504 /* If the argument has a default argument, we consider it 7505 non-canonical even though the type itself is canonical. 7506 That way, different variants of function and method types 7507 with default arguments will all point to the variant with 7508 no defaults as their canonical type. */ 7509 any_noncanonical_argtypes_p = true; 7510 } 7511 7512 if (*any_structural_p) 7513 return argtypes; 7514 7515 if (any_noncanonical_argtypes_p) 7516 { 7517 /* Build the canonical list of argument types. */ 7518 tree canon_argtypes = NULL_TREE; 7519 bool is_void = false; 7520 7521 for (arg = argtypes; arg; arg = TREE_CHAIN (arg)) 7522 { 7523 if (arg == void_list_node) 7524 is_void = true; 7525 else 7526 canon_argtypes = tree_cons (NULL_TREE, 7527 TYPE_CANONICAL (TREE_VALUE (arg)), 7528 canon_argtypes); 7529 } 7530 7531 canon_argtypes = nreverse (canon_argtypes); 7532 if (is_void) 7533 canon_argtypes = chainon (canon_argtypes, void_list_node); 7534 7535 /* There is a non-canonical type. */ 7536 *any_noncanonical_p = true; 7537 return canon_argtypes; 7538 } 7539 7540 /* The canonical argument types are the same as ARGTYPES. */ 7541 return argtypes; 7542 } 7543 7544 /* Construct, lay out and return 7545 the type of functions returning type VALUE_TYPE 7546 given arguments of types ARG_TYPES. 7547 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs 7548 are data type nodes for the arguments of the function. 7549 If such a type has already been constructed, reuse it. */ 7550 7551 tree 7552 build_function_type (tree value_type, tree arg_types) 7553 { 7554 tree t; 7555 hashval_t hashcode = 0; 7556 bool any_structural_p, any_noncanonical_p; 7557 tree canon_argtypes; 7558 7559 if (TREE_CODE (value_type) == FUNCTION_TYPE) 7560 { 7561 error ("function return type cannot be function"); 7562 value_type = integer_type_node; 7563 } 7564 7565 /* Make a node of the sort we want. */ 7566 t = make_node (FUNCTION_TYPE); 7567 TREE_TYPE (t) = value_type; 7568 TYPE_ARG_TYPES (t) = arg_types; 7569 7570 /* If we already have such a type, use the old one. */ 7571 hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode); 7572 hashcode = type_hash_list (arg_types, hashcode); 7573 t = type_hash_canon (hashcode, t); 7574 7575 /* Set up the canonical type. */ 7576 any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type); 7577 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type; 7578 canon_argtypes = maybe_canonicalize_argtypes (arg_types, 7579 &any_structural_p, 7580 &any_noncanonical_p); 7581 if (any_structural_p) 7582 SET_TYPE_STRUCTURAL_EQUALITY (t); 7583 else if (any_noncanonical_p) 7584 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type), 7585 canon_argtypes); 7586 7587 if (!COMPLETE_TYPE_P (t)) 7588 layout_type (t); 7589 return t; 7590 } 7591 7592 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP and the 7593 return value if SKIP_RETURN is true. */ 7594 7595 static tree 7596 build_function_type_skip_args (tree orig_type, bitmap args_to_skip, 7597 bool skip_return) 7598 { 7599 tree new_type = NULL; 7600 tree args, new_args = NULL, t; 7601 tree new_reversed; 7602 int i = 0; 7603 7604 for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node; 7605 args = TREE_CHAIN (args), i++) 7606 if (!args_to_skip || !bitmap_bit_p (args_to_skip, i)) 7607 new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args); 7608 7609 new_reversed = nreverse (new_args); 7610 if (args) 7611 { 7612 if (new_reversed) 7613 TREE_CHAIN (new_args) = void_list_node; 7614 else 7615 new_reversed = void_list_node; 7616 } 7617 7618 /* Use copy_node to preserve as much as possible from original type 7619 (debug info, attribute lists etc.) 7620 Exception is METHOD_TYPEs must have THIS argument. 7621 When we are asked to remove it, we need to build new FUNCTION_TYPE 7622 instead. */ 7623 if (TREE_CODE (orig_type) != METHOD_TYPE 7624 || !args_to_skip 7625 || !bitmap_bit_p (args_to_skip, 0)) 7626 { 7627 new_type = build_distinct_type_copy (orig_type); 7628 TYPE_ARG_TYPES (new_type) = new_reversed; 7629 } 7630 else 7631 { 7632 new_type 7633 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type), 7634 new_reversed)); 7635 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type); 7636 } 7637 7638 if (skip_return) 7639 TREE_TYPE (new_type) = void_type_node; 7640 7641 /* This is a new type, not a copy of an old type. Need to reassociate 7642 variants. We can handle everything except the main variant lazily. */ 7643 t = TYPE_MAIN_VARIANT (orig_type); 7644 if (t != orig_type) 7645 { 7646 t = build_function_type_skip_args (t, args_to_skip, skip_return); 7647 TYPE_MAIN_VARIANT (new_type) = t; 7648 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t); 7649 TYPE_NEXT_VARIANT (t) = new_type; 7650 } 7651 else 7652 { 7653 TYPE_MAIN_VARIANT (new_type) = new_type; 7654 TYPE_NEXT_VARIANT (new_type) = NULL; 7655 } 7656 7657 return new_type; 7658 } 7659 7660 /* Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the 7661 return value if SKIP_RETURN is true. 7662 7663 Arguments from DECL_ARGUMENTS list can't be removed now, since they are 7664 linked by TREE_CHAIN directly. The caller is responsible for eliminating 7665 them when they are being duplicated (i.e. copy_arguments_for_versioning). */ 7666 7667 tree 7668 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip, 7669 bool skip_return) 7670 { 7671 tree new_decl = copy_node (orig_decl); 7672 tree new_type; 7673 7674 new_type = TREE_TYPE (orig_decl); 7675 if (prototype_p (new_type) 7676 || (skip_return && !VOID_TYPE_P (TREE_TYPE (new_type)))) 7677 new_type 7678 = build_function_type_skip_args (new_type, args_to_skip, skip_return); 7679 TREE_TYPE (new_decl) = new_type; 7680 7681 /* For declarations setting DECL_VINDEX (i.e. methods) 7682 we expect first argument to be THIS pointer. */ 7683 if (args_to_skip && bitmap_bit_p (args_to_skip, 0)) 7684 DECL_VINDEX (new_decl) = NULL_TREE; 7685 7686 /* When signature changes, we need to clear builtin info. */ 7687 if (DECL_BUILT_IN (new_decl) 7688 && args_to_skip 7689 && !bitmap_empty_p (args_to_skip)) 7690 { 7691 DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN; 7692 DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0; 7693 } 7694 return new_decl; 7695 } 7696 7697 /* Build a function type. The RETURN_TYPE is the type returned by the 7698 function. If VAARGS is set, no void_type_node is appended to the 7699 the list. ARGP must be always be terminated be a NULL_TREE. */ 7700 7701 static tree 7702 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp) 7703 { 7704 tree t, args, last; 7705 7706 t = va_arg (argp, tree); 7707 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree)) 7708 args = tree_cons (NULL_TREE, t, args); 7709 7710 if (vaargs) 7711 { 7712 last = args; 7713 if (args != NULL_TREE) 7714 args = nreverse (args); 7715 gcc_assert (last != void_list_node); 7716 } 7717 else if (args == NULL_TREE) 7718 args = void_list_node; 7719 else 7720 { 7721 last = args; 7722 args = nreverse (args); 7723 TREE_CHAIN (last) = void_list_node; 7724 } 7725 args = build_function_type (return_type, args); 7726 7727 return args; 7728 } 7729 7730 /* Build a function type. The RETURN_TYPE is the type returned by the 7731 function. If additional arguments are provided, they are 7732 additional argument types. The list of argument types must always 7733 be terminated by NULL_TREE. */ 7734 7735 tree 7736 build_function_type_list (tree return_type, ...) 7737 { 7738 tree args; 7739 va_list p; 7740 7741 va_start (p, return_type); 7742 args = build_function_type_list_1 (false, return_type, p); 7743 va_end (p); 7744 return args; 7745 } 7746 7747 /* Build a variable argument function type. The RETURN_TYPE is the 7748 type returned by the function. If additional arguments are provided, 7749 they are additional argument types. The list of argument types must 7750 always be terminated by NULL_TREE. */ 7751 7752 tree 7753 build_varargs_function_type_list (tree return_type, ...) 7754 { 7755 tree args; 7756 va_list p; 7757 7758 va_start (p, return_type); 7759 args = build_function_type_list_1 (true, return_type, p); 7760 va_end (p); 7761 7762 return args; 7763 } 7764 7765 /* Build a function type. RETURN_TYPE is the type returned by the 7766 function; VAARGS indicates whether the function takes varargs. The 7767 function takes N named arguments, the types of which are provided in 7768 ARG_TYPES. */ 7769 7770 static tree 7771 build_function_type_array_1 (bool vaargs, tree return_type, int n, 7772 tree *arg_types) 7773 { 7774 int i; 7775 tree t = vaargs ? NULL_TREE : void_list_node; 7776 7777 for (i = n - 1; i >= 0; i--) 7778 t = tree_cons (NULL_TREE, arg_types[i], t); 7779 7780 return build_function_type (return_type, t); 7781 } 7782 7783 /* Build a function type. RETURN_TYPE is the type returned by the 7784 function. The function takes N named arguments, the types of which 7785 are provided in ARG_TYPES. */ 7786 7787 tree 7788 build_function_type_array (tree return_type, int n, tree *arg_types) 7789 { 7790 return build_function_type_array_1 (false, return_type, n, arg_types); 7791 } 7792 7793 /* Build a variable argument function type. RETURN_TYPE is the type 7794 returned by the function. The function takes N named arguments, the 7795 types of which are provided in ARG_TYPES. */ 7796 7797 tree 7798 build_varargs_function_type_array (tree return_type, int n, tree *arg_types) 7799 { 7800 return build_function_type_array_1 (true, return_type, n, arg_types); 7801 } 7802 7803 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE) 7804 and ARGTYPES (a TREE_LIST) are the return type and arguments types 7805 for the method. An implicit additional parameter (of type 7806 pointer-to-BASETYPE) is added to the ARGTYPES. */ 7807 7808 tree 7809 build_method_type_directly (tree basetype, 7810 tree rettype, 7811 tree argtypes) 7812 { 7813 tree t; 7814 tree ptype; 7815 int hashcode = 0; 7816 bool any_structural_p, any_noncanonical_p; 7817 tree canon_argtypes; 7818 7819 /* Make a node of the sort we want. */ 7820 t = make_node (METHOD_TYPE); 7821 7822 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); 7823 TREE_TYPE (t) = rettype; 7824 ptype = build_pointer_type (basetype); 7825 7826 /* The actual arglist for this function includes a "hidden" argument 7827 which is "this". Put it into the list of argument types. */ 7828 argtypes = tree_cons (NULL_TREE, ptype, argtypes); 7829 TYPE_ARG_TYPES (t) = argtypes; 7830 7831 /* If we already have such a type, use the old one. */ 7832 hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode); 7833 hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode); 7834 hashcode = type_hash_list (argtypes, hashcode); 7835 t = type_hash_canon (hashcode, t); 7836 7837 /* Set up the canonical type. */ 7838 any_structural_p 7839 = (TYPE_STRUCTURAL_EQUALITY_P (basetype) 7840 || TYPE_STRUCTURAL_EQUALITY_P (rettype)); 7841 any_noncanonical_p 7842 = (TYPE_CANONICAL (basetype) != basetype 7843 || TYPE_CANONICAL (rettype) != rettype); 7844 canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes), 7845 &any_structural_p, 7846 &any_noncanonical_p); 7847 if (any_structural_p) 7848 SET_TYPE_STRUCTURAL_EQUALITY (t); 7849 else if (any_noncanonical_p) 7850 TYPE_CANONICAL (t) 7851 = build_method_type_directly (TYPE_CANONICAL (basetype), 7852 TYPE_CANONICAL (rettype), 7853 canon_argtypes); 7854 if (!COMPLETE_TYPE_P (t)) 7855 layout_type (t); 7856 7857 return t; 7858 } 7859 7860 /* Construct, lay out and return the type of methods belonging to class 7861 BASETYPE and whose arguments and values are described by TYPE. 7862 If that type exists already, reuse it. 7863 TYPE must be a FUNCTION_TYPE node. */ 7864 7865 tree 7866 build_method_type (tree basetype, tree type) 7867 { 7868 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE); 7869 7870 return build_method_type_directly (basetype, 7871 TREE_TYPE (type), 7872 TYPE_ARG_TYPES (type)); 7873 } 7874 7875 /* Construct, lay out and return the type of offsets to a value 7876 of type TYPE, within an object of type BASETYPE. 7877 If a suitable offset type exists already, reuse it. */ 7878 7879 tree 7880 build_offset_type (tree basetype, tree type) 7881 { 7882 tree t; 7883 hashval_t hashcode = 0; 7884 7885 /* Make a node of the sort we want. */ 7886 t = make_node (OFFSET_TYPE); 7887 7888 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); 7889 TREE_TYPE (t) = type; 7890 7891 /* If we already have such a type, use the old one. */ 7892 hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode); 7893 hashcode = iterative_hash_object (TYPE_HASH (type), hashcode); 7894 t = type_hash_canon (hashcode, t); 7895 7896 if (!COMPLETE_TYPE_P (t)) 7897 layout_type (t); 7898 7899 if (TYPE_CANONICAL (t) == t) 7900 { 7901 if (TYPE_STRUCTURAL_EQUALITY_P (basetype) 7902 || TYPE_STRUCTURAL_EQUALITY_P (type)) 7903 SET_TYPE_STRUCTURAL_EQUALITY (t); 7904 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype 7905 || TYPE_CANONICAL (type) != type) 7906 TYPE_CANONICAL (t) 7907 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)), 7908 TYPE_CANONICAL (type)); 7909 } 7910 7911 return t; 7912 } 7913 7914 /* Create a complex type whose components are COMPONENT_TYPE. */ 7915 7916 tree 7917 build_complex_type (tree component_type) 7918 { 7919 tree t; 7920 hashval_t hashcode; 7921 7922 gcc_assert (INTEGRAL_TYPE_P (component_type) 7923 || SCALAR_FLOAT_TYPE_P (component_type) 7924 || FIXED_POINT_TYPE_P (component_type)); 7925 7926 /* Make a node of the sort we want. */ 7927 t = make_node (COMPLEX_TYPE); 7928 7929 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type); 7930 7931 /* If we already have such a type, use the old one. */ 7932 hashcode = iterative_hash_object (TYPE_HASH (component_type), 0); 7933 t = type_hash_canon (hashcode, t); 7934 7935 if (!COMPLETE_TYPE_P (t)) 7936 layout_type (t); 7937 7938 if (TYPE_CANONICAL (t) == t) 7939 { 7940 if (TYPE_STRUCTURAL_EQUALITY_P (component_type)) 7941 SET_TYPE_STRUCTURAL_EQUALITY (t); 7942 else if (TYPE_CANONICAL (component_type) != component_type) 7943 TYPE_CANONICAL (t) 7944 = build_complex_type (TYPE_CANONICAL (component_type)); 7945 } 7946 7947 /* We need to create a name, since complex is a fundamental type. */ 7948 if (! TYPE_NAME (t)) 7949 { 7950 const char *name; 7951 if (component_type == char_type_node) 7952 name = "complex char"; 7953 else if (component_type == signed_char_type_node) 7954 name = "complex signed char"; 7955 else if (component_type == unsigned_char_type_node) 7956 name = "complex unsigned char"; 7957 else if (component_type == short_integer_type_node) 7958 name = "complex short int"; 7959 else if (component_type == short_unsigned_type_node) 7960 name = "complex short unsigned int"; 7961 else if (component_type == integer_type_node) 7962 name = "complex int"; 7963 else if (component_type == unsigned_type_node) 7964 name = "complex unsigned int"; 7965 else if (component_type == long_integer_type_node) 7966 name = "complex long int"; 7967 else if (component_type == long_unsigned_type_node) 7968 name = "complex long unsigned int"; 7969 else if (component_type == long_long_integer_type_node) 7970 name = "complex long long int"; 7971 else if (component_type == long_long_unsigned_type_node) 7972 name = "complex long long unsigned int"; 7973 else 7974 name = 0; 7975 7976 if (name != 0) 7977 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, 7978 get_identifier (name), t); 7979 } 7980 7981 return build_qualified_type (t, TYPE_QUALS (component_type)); 7982 } 7983 7984 /* If TYPE is a real or complex floating-point type and the target 7985 does not directly support arithmetic on TYPE then return the wider 7986 type to be used for arithmetic on TYPE. Otherwise, return 7987 NULL_TREE. */ 7988 7989 tree 7990 excess_precision_type (tree type) 7991 { 7992 if (flag_excess_precision != EXCESS_PRECISION_FAST) 7993 { 7994 int flt_eval_method = TARGET_FLT_EVAL_METHOD; 7995 switch (TREE_CODE (type)) 7996 { 7997 case REAL_TYPE: 7998 switch (flt_eval_method) 7999 { 8000 case 1: 8001 if (TYPE_MODE (type) == TYPE_MODE (float_type_node)) 8002 return double_type_node; 8003 break; 8004 case 2: 8005 if (TYPE_MODE (type) == TYPE_MODE (float_type_node) 8006 || TYPE_MODE (type) == TYPE_MODE (double_type_node)) 8007 return long_double_type_node; 8008 break; 8009 default: 8010 gcc_unreachable (); 8011 } 8012 break; 8013 case COMPLEX_TYPE: 8014 if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE) 8015 return NULL_TREE; 8016 switch (flt_eval_method) 8017 { 8018 case 1: 8019 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)) 8020 return complex_double_type_node; 8021 break; 8022 case 2: 8023 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node) 8024 || (TYPE_MODE (TREE_TYPE (type)) 8025 == TYPE_MODE (double_type_node))) 8026 return complex_long_double_type_node; 8027 break; 8028 default: 8029 gcc_unreachable (); 8030 } 8031 break; 8032 default: 8033 break; 8034 } 8035 } 8036 return NULL_TREE; 8037 } 8038 8039 /* Return OP, stripped of any conversions to wider types as much as is safe. 8040 Converting the value back to OP's type makes a value equivalent to OP. 8041 8042 If FOR_TYPE is nonzero, we return a value which, if converted to 8043 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE. 8044 8045 OP must have integer, real or enumeral type. Pointers are not allowed! 8046 8047 There are some cases where the obvious value we could return 8048 would regenerate to OP if converted to OP's type, 8049 but would not extend like OP to wider types. 8050 If FOR_TYPE indicates such extension is contemplated, we eschew such values. 8051 For example, if OP is (unsigned short)(signed char)-1, 8052 we avoid returning (signed char)-1 if FOR_TYPE is int, 8053 even though extending that to an unsigned short would regenerate OP, 8054 since the result of extending (signed char)-1 to (int) 8055 is different from (int) OP. */ 8056 8057 tree 8058 get_unwidened (tree op, tree for_type) 8059 { 8060 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */ 8061 tree type = TREE_TYPE (op); 8062 unsigned final_prec 8063 = TYPE_PRECISION (for_type != 0 ? for_type : type); 8064 int uns 8065 = (for_type != 0 && for_type != type 8066 && final_prec > TYPE_PRECISION (type) 8067 && TYPE_UNSIGNED (type)); 8068 tree win = op; 8069 8070 while (CONVERT_EXPR_P (op)) 8071 { 8072 int bitschange; 8073 8074 /* TYPE_PRECISION on vector types has different meaning 8075 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions, 8076 so avoid them here. */ 8077 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE) 8078 break; 8079 8080 bitschange = TYPE_PRECISION (TREE_TYPE (op)) 8081 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))); 8082 8083 /* Truncations are many-one so cannot be removed. 8084 Unless we are later going to truncate down even farther. */ 8085 if (bitschange < 0 8086 && final_prec > TYPE_PRECISION (TREE_TYPE (op))) 8087 break; 8088 8089 /* See what's inside this conversion. If we decide to strip it, 8090 we will set WIN. */ 8091 op = TREE_OPERAND (op, 0); 8092 8093 /* If we have not stripped any zero-extensions (uns is 0), 8094 we can strip any kind of extension. 8095 If we have previously stripped a zero-extension, 8096 only zero-extensions can safely be stripped. 8097 Any extension can be stripped if the bits it would produce 8098 are all going to be discarded later by truncating to FOR_TYPE. */ 8099 8100 if (bitschange > 0) 8101 { 8102 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op))) 8103 win = op; 8104 /* TYPE_UNSIGNED says whether this is a zero-extension. 8105 Let's avoid computing it if it does not affect WIN 8106 and if UNS will not be needed again. */ 8107 if ((uns 8108 || CONVERT_EXPR_P (op)) 8109 && TYPE_UNSIGNED (TREE_TYPE (op))) 8110 { 8111 uns = 1; 8112 win = op; 8113 } 8114 } 8115 } 8116 8117 /* If we finally reach a constant see if it fits in for_type and 8118 in that case convert it. */ 8119 if (for_type 8120 && TREE_CODE (win) == INTEGER_CST 8121 && TREE_TYPE (win) != for_type 8122 && int_fits_type_p (win, for_type)) 8123 win = fold_convert (for_type, win); 8124 8125 return win; 8126 } 8127 8128 /* Return OP or a simpler expression for a narrower value 8129 which can be sign-extended or zero-extended to give back OP. 8130 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended 8131 or 0 if the value should be sign-extended. */ 8132 8133 tree 8134 get_narrower (tree op, int *unsignedp_ptr) 8135 { 8136 int uns = 0; 8137 int first = 1; 8138 tree win = op; 8139 bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op)); 8140 8141 while (TREE_CODE (op) == NOP_EXPR) 8142 { 8143 int bitschange 8144 = (TYPE_PRECISION (TREE_TYPE (op)) 8145 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)))); 8146 8147 /* Truncations are many-one so cannot be removed. */ 8148 if (bitschange < 0) 8149 break; 8150 8151 /* See what's inside this conversion. If we decide to strip it, 8152 we will set WIN. */ 8153 8154 if (bitschange > 0) 8155 { 8156 op = TREE_OPERAND (op, 0); 8157 /* An extension: the outermost one can be stripped, 8158 but remember whether it is zero or sign extension. */ 8159 if (first) 8160 uns = TYPE_UNSIGNED (TREE_TYPE (op)); 8161 /* Otherwise, if a sign extension has been stripped, 8162 only sign extensions can now be stripped; 8163 if a zero extension has been stripped, only zero-extensions. */ 8164 else if (uns != TYPE_UNSIGNED (TREE_TYPE (op))) 8165 break; 8166 first = 0; 8167 } 8168 else /* bitschange == 0 */ 8169 { 8170 /* A change in nominal type can always be stripped, but we must 8171 preserve the unsignedness. */ 8172 if (first) 8173 uns = TYPE_UNSIGNED (TREE_TYPE (op)); 8174 first = 0; 8175 op = TREE_OPERAND (op, 0); 8176 /* Keep trying to narrow, but don't assign op to win if it 8177 would turn an integral type into something else. */ 8178 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p) 8179 continue; 8180 } 8181 8182 win = op; 8183 } 8184 8185 if (TREE_CODE (op) == COMPONENT_REF 8186 /* Since type_for_size always gives an integer type. */ 8187 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE 8188 && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE 8189 /* Ensure field is laid out already. */ 8190 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0 8191 && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1)) 8192 { 8193 unsigned HOST_WIDE_INT innerprec 8194 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); 8195 int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1)) 8196 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); 8197 tree type = lang_hooks.types.type_for_size (innerprec, unsignedp); 8198 8199 /* We can get this structure field in a narrower type that fits it, 8200 but the resulting extension to its nominal type (a fullword type) 8201 must satisfy the same conditions as for other extensions. 8202 8203 Do this only for fields that are aligned (not bit-fields), 8204 because when bit-field insns will be used there is no 8205 advantage in doing this. */ 8206 8207 if (innerprec < TYPE_PRECISION (TREE_TYPE (op)) 8208 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)) 8209 && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1))) 8210 && type != 0) 8211 { 8212 if (first) 8213 uns = DECL_UNSIGNED (TREE_OPERAND (op, 1)); 8214 win = fold_convert (type, op); 8215 } 8216 } 8217 8218 *unsignedp_ptr = uns; 8219 return win; 8220 } 8221 8222 /* Returns true if integer constant C has a value that is permissible 8223 for type TYPE (an INTEGER_TYPE). */ 8224 8225 bool 8226 int_fits_type_p (const_tree c, const_tree type) 8227 { 8228 tree type_low_bound, type_high_bound; 8229 bool ok_for_low_bound, ok_for_high_bound, unsc; 8230 double_int dc, dd; 8231 8232 dc = tree_to_double_int (c); 8233 unsc = TYPE_UNSIGNED (TREE_TYPE (c)); 8234 8235 if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE 8236 && TYPE_IS_SIZETYPE (TREE_TYPE (c)) 8237 && unsc) 8238 /* So c is an unsigned integer whose type is sizetype and type is not. 8239 sizetype'd integers are sign extended even though they are 8240 unsigned. If the integer value fits in the lower end word of c, 8241 and if the higher end word has all its bits set to 1, that 8242 means the higher end bits are set to 1 only for sign extension. 8243 So let's convert c into an equivalent zero extended unsigned 8244 integer. */ 8245 dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c))); 8246 8247 retry: 8248 type_low_bound = TYPE_MIN_VALUE (type); 8249 type_high_bound = TYPE_MAX_VALUE (type); 8250 8251 /* If at least one bound of the type is a constant integer, we can check 8252 ourselves and maybe make a decision. If no such decision is possible, but 8253 this type is a subtype, try checking against that. Otherwise, use 8254 double_int_fits_to_tree_p, which checks against the precision. 8255 8256 Compute the status for each possibly constant bound, and return if we see 8257 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1 8258 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1 8259 for "constant known to fit". */ 8260 8261 /* Check if c >= type_low_bound. */ 8262 if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST) 8263 { 8264 dd = tree_to_double_int (type_low_bound); 8265 if (TREE_CODE (type) == INTEGER_TYPE 8266 && TYPE_IS_SIZETYPE (type) 8267 && TYPE_UNSIGNED (type)) 8268 dd = double_int_zext (dd, TYPE_PRECISION (type)); 8269 if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound))) 8270 { 8271 int c_neg = (!unsc && double_int_negative_p (dc)); 8272 int t_neg = (unsc && double_int_negative_p (dd)); 8273 8274 if (c_neg && !t_neg) 8275 return false; 8276 if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0) 8277 return false; 8278 } 8279 else if (double_int_cmp (dc, dd, unsc) < 0) 8280 return false; 8281 ok_for_low_bound = true; 8282 } 8283 else 8284 ok_for_low_bound = false; 8285 8286 /* Check if c <= type_high_bound. */ 8287 if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST) 8288 { 8289 dd = tree_to_double_int (type_high_bound); 8290 if (TREE_CODE (type) == INTEGER_TYPE 8291 && TYPE_IS_SIZETYPE (type) 8292 && TYPE_UNSIGNED (type)) 8293 dd = double_int_zext (dd, TYPE_PRECISION (type)); 8294 if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound))) 8295 { 8296 int c_neg = (!unsc && double_int_negative_p (dc)); 8297 int t_neg = (unsc && double_int_negative_p (dd)); 8298 8299 if (t_neg && !c_neg) 8300 return false; 8301 if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0) 8302 return false; 8303 } 8304 else if (double_int_cmp (dc, dd, unsc) > 0) 8305 return false; 8306 ok_for_high_bound = true; 8307 } 8308 else 8309 ok_for_high_bound = false; 8310 8311 /* If the constant fits both bounds, the result is known. */ 8312 if (ok_for_low_bound && ok_for_high_bound) 8313 return true; 8314 8315 /* Perform some generic filtering which may allow making a decision 8316 even if the bounds are not constant. First, negative integers 8317 never fit in unsigned types, */ 8318 if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc)) 8319 return false; 8320 8321 /* Second, narrower types always fit in wider ones. */ 8322 if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c))) 8323 return true; 8324 8325 /* Third, unsigned integers with top bit set never fit signed types. */ 8326 if (! TYPE_UNSIGNED (type) && unsc) 8327 { 8328 int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1; 8329 if (prec < HOST_BITS_PER_WIDE_INT) 8330 { 8331 if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0) 8332 return false; 8333 } 8334 else if (((((unsigned HOST_WIDE_INT) 1) 8335 << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0) 8336 return false; 8337 } 8338 8339 /* If we haven't been able to decide at this point, there nothing more we 8340 can check ourselves here. Look at the base type if we have one and it 8341 has the same precision. */ 8342 if (TREE_CODE (type) == INTEGER_TYPE 8343 && TREE_TYPE (type) != 0 8344 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type))) 8345 { 8346 type = TREE_TYPE (type); 8347 goto retry; 8348 } 8349 8350 /* Or to double_int_fits_to_tree_p, if nothing else. */ 8351 return double_int_fits_to_tree_p (type, dc); 8352 } 8353 8354 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant 8355 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be 8356 represented (assuming two's-complement arithmetic) within the bit 8357 precision of the type are returned instead. */ 8358 8359 void 8360 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max) 8361 { 8362 if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type) 8363 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST) 8364 mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)), 8365 TYPE_UNSIGNED (type)); 8366 else 8367 { 8368 if (TYPE_UNSIGNED (type)) 8369 mpz_set_ui (min, 0); 8370 else 8371 { 8372 double_int mn; 8373 mn = double_int_mask (TYPE_PRECISION (type) - 1); 8374 mn = double_int_sext (double_int_add (mn, double_int_one), 8375 TYPE_PRECISION (type)); 8376 mpz_set_double_int (min, mn, false); 8377 } 8378 } 8379 8380 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type) 8381 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST) 8382 mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)), 8383 TYPE_UNSIGNED (type)); 8384 else 8385 { 8386 if (TYPE_UNSIGNED (type)) 8387 mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)), 8388 true); 8389 else 8390 mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1), 8391 true); 8392 } 8393 } 8394 8395 /* Return true if VAR is an automatic variable defined in function FN. */ 8396 8397 bool 8398 auto_var_in_fn_p (const_tree var, const_tree fn) 8399 { 8400 return (DECL_P (var) && DECL_CONTEXT (var) == fn 8401 && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var)) 8402 || TREE_CODE (var) == PARM_DECL) 8403 && ! TREE_STATIC (var)) 8404 || TREE_CODE (var) == LABEL_DECL 8405 || TREE_CODE (var) == RESULT_DECL)); 8406 } 8407 8408 /* Subprogram of following function. Called by walk_tree. 8409 8410 Return *TP if it is an automatic variable or parameter of the 8411 function passed in as DATA. */ 8412 8413 static tree 8414 find_var_from_fn (tree *tp, int *walk_subtrees, void *data) 8415 { 8416 tree fn = (tree) data; 8417 8418 if (TYPE_P (*tp)) 8419 *walk_subtrees = 0; 8420 8421 else if (DECL_P (*tp) 8422 && auto_var_in_fn_p (*tp, fn)) 8423 return *tp; 8424 8425 return NULL_TREE; 8426 } 8427 8428 /* Returns true if T is, contains, or refers to a type with variable 8429 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the 8430 arguments, but not the return type. If FN is nonzero, only return 8431 true if a modifier of the type or position of FN is a variable or 8432 parameter inside FN. 8433 8434 This concept is more general than that of C99 'variably modified types': 8435 in C99, a struct type is never variably modified because a VLA may not 8436 appear as a structure member. However, in GNU C code like: 8437 8438 struct S { int i[f()]; }; 8439 8440 is valid, and other languages may define similar constructs. */ 8441 8442 bool 8443 variably_modified_type_p (tree type, tree fn) 8444 { 8445 tree t; 8446 8447 /* Test if T is either variable (if FN is zero) or an expression containing 8448 a variable in FN. */ 8449 #define RETURN_TRUE_IF_VAR(T) \ 8450 do { tree _t = (T); \ 8451 if (_t != NULL_TREE \ 8452 && _t != error_mark_node \ 8453 && TREE_CODE (_t) != INTEGER_CST \ 8454 && TREE_CODE (_t) != PLACEHOLDER_EXPR \ 8455 && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \ 8456 return true; } while (0) 8457 8458 if (type == error_mark_node) 8459 return false; 8460 8461 /* If TYPE itself has variable size, it is variably modified. */ 8462 RETURN_TRUE_IF_VAR (TYPE_SIZE (type)); 8463 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type)); 8464 8465 switch (TREE_CODE (type)) 8466 { 8467 case POINTER_TYPE: 8468 case REFERENCE_TYPE: 8469 case VECTOR_TYPE: 8470 if (variably_modified_type_p (TREE_TYPE (type), fn)) 8471 return true; 8472 break; 8473 8474 case FUNCTION_TYPE: 8475 case METHOD_TYPE: 8476 /* If TYPE is a function type, it is variably modified if the 8477 return type is variably modified. */ 8478 if (variably_modified_type_p (TREE_TYPE (type), fn)) 8479 return true; 8480 break; 8481 8482 case INTEGER_TYPE: 8483 case REAL_TYPE: 8484 case FIXED_POINT_TYPE: 8485 case ENUMERAL_TYPE: 8486 case BOOLEAN_TYPE: 8487 /* Scalar types are variably modified if their end points 8488 aren't constant. */ 8489 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type)); 8490 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type)); 8491 break; 8492 8493 case RECORD_TYPE: 8494 case UNION_TYPE: 8495 case QUAL_UNION_TYPE: 8496 /* We can't see if any of the fields are variably-modified by the 8497 definition we normally use, since that would produce infinite 8498 recursion via pointers. */ 8499 /* This is variably modified if some field's type is. */ 8500 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t)) 8501 if (TREE_CODE (t) == FIELD_DECL) 8502 { 8503 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t)); 8504 RETURN_TRUE_IF_VAR (DECL_SIZE (t)); 8505 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t)); 8506 8507 if (TREE_CODE (type) == QUAL_UNION_TYPE) 8508 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t)); 8509 } 8510 break; 8511 8512 case ARRAY_TYPE: 8513 /* Do not call ourselves to avoid infinite recursion. This is 8514 variably modified if the element type is. */ 8515 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type))); 8516 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type))); 8517 break; 8518 8519 default: 8520 break; 8521 } 8522 8523 /* The current language may have other cases to check, but in general, 8524 all other types are not variably modified. */ 8525 return lang_hooks.tree_inlining.var_mod_type_p (type, fn); 8526 8527 #undef RETURN_TRUE_IF_VAR 8528 } 8529 8530 /* Given a DECL or TYPE, return the scope in which it was declared, or 8531 NULL_TREE if there is no containing scope. */ 8532 8533 tree 8534 get_containing_scope (const_tree t) 8535 { 8536 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t)); 8537 } 8538 8539 /* Return the innermost context enclosing DECL that is 8540 a FUNCTION_DECL, or zero if none. */ 8541 8542 tree 8543 decl_function_context (const_tree decl) 8544 { 8545 tree context; 8546 8547 if (TREE_CODE (decl) == ERROR_MARK) 8548 return 0; 8549 8550 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable 8551 where we look up the function at runtime. Such functions always take 8552 a first argument of type 'pointer to real context'. 8553 8554 C++ should really be fixed to use DECL_CONTEXT for the real context, 8555 and use something else for the "virtual context". */ 8556 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl)) 8557 context 8558 = TYPE_MAIN_VARIANT 8559 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 8560 else 8561 context = DECL_CONTEXT (decl); 8562 8563 while (context && TREE_CODE (context) != FUNCTION_DECL) 8564 { 8565 if (TREE_CODE (context) == BLOCK) 8566 context = BLOCK_SUPERCONTEXT (context); 8567 else 8568 context = get_containing_scope (context); 8569 } 8570 8571 return context; 8572 } 8573 8574 /* Return the innermost context enclosing DECL that is 8575 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none. 8576 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */ 8577 8578 tree 8579 decl_type_context (const_tree decl) 8580 { 8581 tree context = DECL_CONTEXT (decl); 8582 8583 while (context) 8584 switch (TREE_CODE (context)) 8585 { 8586 case NAMESPACE_DECL: 8587 case TRANSLATION_UNIT_DECL: 8588 return NULL_TREE; 8589 8590 case RECORD_TYPE: 8591 case UNION_TYPE: 8592 case QUAL_UNION_TYPE: 8593 return context; 8594 8595 case TYPE_DECL: 8596 case FUNCTION_DECL: 8597 context = DECL_CONTEXT (context); 8598 break; 8599 8600 case BLOCK: 8601 context = BLOCK_SUPERCONTEXT (context); 8602 break; 8603 8604 default: 8605 gcc_unreachable (); 8606 } 8607 8608 return NULL_TREE; 8609 } 8610 8611 /* CALL is a CALL_EXPR. Return the declaration for the function 8612 called, or NULL_TREE if the called function cannot be 8613 determined. */ 8614 8615 tree 8616 get_callee_fndecl (const_tree call) 8617 { 8618 tree addr; 8619 8620 if (call == error_mark_node) 8621 return error_mark_node; 8622 8623 /* It's invalid to call this function with anything but a 8624 CALL_EXPR. */ 8625 gcc_assert (TREE_CODE (call) == CALL_EXPR); 8626 8627 /* The first operand to the CALL is the address of the function 8628 called. */ 8629 addr = CALL_EXPR_FN (call); 8630 8631 STRIP_NOPS (addr); 8632 8633 /* If this is a readonly function pointer, extract its initial value. */ 8634 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL 8635 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr) 8636 && DECL_INITIAL (addr)) 8637 addr = DECL_INITIAL (addr); 8638 8639 /* If the address is just `&f' for some function `f', then we know 8640 that `f' is being called. */ 8641 if (TREE_CODE (addr) == ADDR_EXPR 8642 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL) 8643 return TREE_OPERAND (addr, 0); 8644 8645 /* We couldn't figure out what was being called. */ 8646 return NULL_TREE; 8647 } 8648 8649 /* Print debugging information about tree nodes generated during the compile, 8650 and any language-specific information. */ 8651 8652 void 8653 dump_tree_statistics (void) 8654 { 8655 #ifdef GATHER_STATISTICS 8656 int i; 8657 int total_nodes, total_bytes; 8658 #endif 8659 8660 fprintf (stderr, "\n??? tree nodes created\n\n"); 8661 #ifdef GATHER_STATISTICS 8662 fprintf (stderr, "Kind Nodes Bytes\n"); 8663 fprintf (stderr, "---------------------------------------\n"); 8664 total_nodes = total_bytes = 0; 8665 for (i = 0; i < (int) all_kinds; i++) 8666 { 8667 fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i], 8668 tree_node_counts[i], tree_node_sizes[i]); 8669 total_nodes += tree_node_counts[i]; 8670 total_bytes += tree_node_sizes[i]; 8671 } 8672 fprintf (stderr, "---------------------------------------\n"); 8673 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes); 8674 fprintf (stderr, "---------------------------------------\n"); 8675 fprintf (stderr, "Code Nodes\n"); 8676 fprintf (stderr, "----------------------------\n"); 8677 for (i = 0; i < (int) MAX_TREE_CODES; i++) 8678 fprintf (stderr, "%-20s %7d\n", tree_code_name[i], tree_code_counts[i]); 8679 fprintf (stderr, "----------------------------\n"); 8680 ssanames_print_statistics (); 8681 phinodes_print_statistics (); 8682 #else 8683 fprintf (stderr, "(No per-node statistics)\n"); 8684 #endif 8685 print_type_hash_statistics (); 8686 print_debug_expr_statistics (); 8687 print_value_expr_statistics (); 8688 lang_hooks.print_statistics (); 8689 } 8690 8691 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s" 8692 8693 /* Generate a crc32 of a byte. */ 8694 8695 unsigned 8696 crc32_byte (unsigned chksum, char byte) 8697 { 8698 unsigned value = (unsigned) byte << 24; 8699 unsigned ix; 8700 8701 for (ix = 8; ix--; value <<= 1) 8702 { 8703 unsigned feedback; 8704 8705 feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0; 8706 chksum <<= 1; 8707 chksum ^= feedback; 8708 } 8709 return chksum; 8710 } 8711 8712 8713 /* Generate a crc32 of a string. */ 8714 8715 unsigned 8716 crc32_string (unsigned chksum, const char *string) 8717 { 8718 do 8719 { 8720 chksum = crc32_byte (chksum, *string); 8721 } 8722 while (*string++); 8723 return chksum; 8724 } 8725 8726 /* P is a string that will be used in a symbol. Mask out any characters 8727 that are not valid in that context. */ 8728 8729 void 8730 clean_symbol_name (char *p) 8731 { 8732 for (; *p; p++) 8733 if (! (ISALNUM (*p) 8734 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */ 8735 || *p == '$' 8736 #endif 8737 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */ 8738 || *p == '.' 8739 #endif 8740 )) 8741 *p = '_'; 8742 } 8743 8744 /* Generate a name for a special-purpose function. 8745 The generated name may need to be unique across the whole link. 8746 Changes to this function may also require corresponding changes to 8747 xstrdup_mask_random. 8748 TYPE is some string to identify the purpose of this function to the 8749 linker or collect2; it must start with an uppercase letter, 8750 one of: 8751 I - for constructors 8752 D - for destructors 8753 N - for C++ anonymous namespaces 8754 F - for DWARF unwind frame information. */ 8755 8756 tree 8757 get_file_function_name (const char *type) 8758 { 8759 char *buf; 8760 const char *p; 8761 char *q; 8762 8763 /* If we already have a name we know to be unique, just use that. */ 8764 if (first_global_object_name) 8765 p = q = ASTRDUP (first_global_object_name); 8766 /* If the target is handling the constructors/destructors, they 8767 will be local to this file and the name is only necessary for 8768 debugging purposes. 8769 We also assign sub_I and sub_D sufixes to constructors called from 8770 the global static constructors. These are always local. */ 8771 else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors) 8772 || (strncmp (type, "sub_", 4) == 0 8773 && (type[4] == 'I' || type[4] == 'D'))) 8774 { 8775 const char *file = main_input_filename; 8776 if (! file) 8777 file = input_filename; 8778 /* Just use the file's basename, because the full pathname 8779 might be quite long. */ 8780 p = q = ASTRDUP (lbasename (file)); 8781 } 8782 else 8783 { 8784 /* Otherwise, the name must be unique across the entire link. 8785 We don't have anything that we know to be unique to this translation 8786 unit, so use what we do have and throw in some randomness. */ 8787 unsigned len; 8788 const char *name = weak_global_object_name; 8789 const char *file = main_input_filename; 8790 8791 if (! name) 8792 name = ""; 8793 if (! file) 8794 file = input_filename; 8795 8796 len = strlen (file); 8797 q = (char *) alloca (9 + 17 + len + 1); 8798 memcpy (q, file, len + 1); 8799 8800 snprintf (q + len, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX, 8801 crc32_string (0, name), get_random_seed (false)); 8802 8803 p = q; 8804 } 8805 8806 clean_symbol_name (q); 8807 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) 8808 + strlen (type)); 8809 8810 /* Set up the name of the file-level functions we may need. 8811 Use a global object (which is already required to be unique over 8812 the program) rather than the file name (which imposes extra 8813 constraints). */ 8814 sprintf (buf, FILE_FUNCTION_FORMAT, type, p); 8815 8816 return get_identifier (buf); 8817 } 8818 8819 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 8820 8821 /* Complain that the tree code of NODE does not match the expected 0 8822 terminated list of trailing codes. The trailing code list can be 8823 empty, for a more vague error message. FILE, LINE, and FUNCTION 8824 are of the caller. */ 8825 8826 void 8827 tree_check_failed (const_tree node, const char *file, 8828 int line, const char *function, ...) 8829 { 8830 va_list args; 8831 const char *buffer; 8832 unsigned length = 0; 8833 int code; 8834 8835 va_start (args, function); 8836 while ((code = va_arg (args, int))) 8837 length += 4 + strlen (tree_code_name[code]); 8838 va_end (args); 8839 if (length) 8840 { 8841 char *tmp; 8842 va_start (args, function); 8843 length += strlen ("expected "); 8844 buffer = tmp = (char *) alloca (length); 8845 length = 0; 8846 while ((code = va_arg (args, int))) 8847 { 8848 const char *prefix = length ? " or " : "expected "; 8849 8850 strcpy (tmp + length, prefix); 8851 length += strlen (prefix); 8852 strcpy (tmp + length, tree_code_name[code]); 8853 length += strlen (tree_code_name[code]); 8854 } 8855 va_end (args); 8856 } 8857 else 8858 buffer = "unexpected node"; 8859 8860 internal_error ("tree check: %s, have %s in %s, at %s:%d", 8861 buffer, tree_code_name[TREE_CODE (node)], 8862 function, trim_filename (file), line); 8863 } 8864 8865 /* Complain that the tree code of NODE does match the expected 0 8866 terminated list of trailing codes. FILE, LINE, and FUNCTION are of 8867 the caller. */ 8868 8869 void 8870 tree_not_check_failed (const_tree node, const char *file, 8871 int line, const char *function, ...) 8872 { 8873 va_list args; 8874 char *buffer; 8875 unsigned length = 0; 8876 int code; 8877 8878 va_start (args, function); 8879 while ((code = va_arg (args, int))) 8880 length += 4 + strlen (tree_code_name[code]); 8881 va_end (args); 8882 va_start (args, function); 8883 buffer = (char *) alloca (length); 8884 length = 0; 8885 while ((code = va_arg (args, int))) 8886 { 8887 if (length) 8888 { 8889 strcpy (buffer + length, " or "); 8890 length += 4; 8891 } 8892 strcpy (buffer + length, tree_code_name[code]); 8893 length += strlen (tree_code_name[code]); 8894 } 8895 va_end (args); 8896 8897 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d", 8898 buffer, tree_code_name[TREE_CODE (node)], 8899 function, trim_filename (file), line); 8900 } 8901 8902 /* Similar to tree_check_failed, except that we check for a class of tree 8903 code, given in CL. */ 8904 8905 void 8906 tree_class_check_failed (const_tree node, const enum tree_code_class cl, 8907 const char *file, int line, const char *function) 8908 { 8909 internal_error 8910 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d", 8911 TREE_CODE_CLASS_STRING (cl), 8912 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))), 8913 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); 8914 } 8915 8916 /* Similar to tree_check_failed, except that instead of specifying a 8917 dozen codes, use the knowledge that they're all sequential. */ 8918 8919 void 8920 tree_range_check_failed (const_tree node, const char *file, int line, 8921 const char *function, enum tree_code c1, 8922 enum tree_code c2) 8923 { 8924 char *buffer; 8925 unsigned length = 0; 8926 unsigned int c; 8927 8928 for (c = c1; c <= c2; ++c) 8929 length += 4 + strlen (tree_code_name[c]); 8930 8931 length += strlen ("expected "); 8932 buffer = (char *) alloca (length); 8933 length = 0; 8934 8935 for (c = c1; c <= c2; ++c) 8936 { 8937 const char *prefix = length ? " or " : "expected "; 8938 8939 strcpy (buffer + length, prefix); 8940 length += strlen (prefix); 8941 strcpy (buffer + length, tree_code_name[c]); 8942 length += strlen (tree_code_name[c]); 8943 } 8944 8945 internal_error ("tree check: %s, have %s in %s, at %s:%d", 8946 buffer, tree_code_name[TREE_CODE (node)], 8947 function, trim_filename (file), line); 8948 } 8949 8950 8951 /* Similar to tree_check_failed, except that we check that a tree does 8952 not have the specified code, given in CL. */ 8953 8954 void 8955 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl, 8956 const char *file, int line, const char *function) 8957 { 8958 internal_error 8959 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d", 8960 TREE_CODE_CLASS_STRING (cl), 8961 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))), 8962 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); 8963 } 8964 8965 8966 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */ 8967 8968 void 8969 omp_clause_check_failed (const_tree node, const char *file, int line, 8970 const char *function, enum omp_clause_code code) 8971 { 8972 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d", 8973 omp_clause_code_name[code], tree_code_name[TREE_CODE (node)], 8974 function, trim_filename (file), line); 8975 } 8976 8977 8978 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */ 8979 8980 void 8981 omp_clause_range_check_failed (const_tree node, const char *file, int line, 8982 const char *function, enum omp_clause_code c1, 8983 enum omp_clause_code c2) 8984 { 8985 char *buffer; 8986 unsigned length = 0; 8987 unsigned int c; 8988 8989 for (c = c1; c <= c2; ++c) 8990 length += 4 + strlen (omp_clause_code_name[c]); 8991 8992 length += strlen ("expected "); 8993 buffer = (char *) alloca (length); 8994 length = 0; 8995 8996 for (c = c1; c <= c2; ++c) 8997 { 8998 const char *prefix = length ? " or " : "expected "; 8999 9000 strcpy (buffer + length, prefix); 9001 length += strlen (prefix); 9002 strcpy (buffer + length, omp_clause_code_name[c]); 9003 length += strlen (omp_clause_code_name[c]); 9004 } 9005 9006 internal_error ("tree check: %s, have %s in %s, at %s:%d", 9007 buffer, omp_clause_code_name[TREE_CODE (node)], 9008 function, trim_filename (file), line); 9009 } 9010 9011 9012 #undef DEFTREESTRUCT 9013 #define DEFTREESTRUCT(VAL, NAME) NAME, 9014 9015 static const char *ts_enum_names[] = { 9016 #include "treestruct.def" 9017 }; 9018 #undef DEFTREESTRUCT 9019 9020 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)]) 9021 9022 /* Similar to tree_class_check_failed, except that we check for 9023 whether CODE contains the tree structure identified by EN. */ 9024 9025 void 9026 tree_contains_struct_check_failed (const_tree node, 9027 const enum tree_node_structure_enum en, 9028 const char *file, int line, 9029 const char *function) 9030 { 9031 internal_error 9032 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d", 9033 TS_ENUM_NAME(en), 9034 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); 9035 } 9036 9037 9038 /* Similar to above, except that the check is for the bounds of a TREE_VEC's 9039 (dynamically sized) vector. */ 9040 9041 void 9042 tree_vec_elt_check_failed (int idx, int len, const char *file, int line, 9043 const char *function) 9044 { 9045 internal_error 9046 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d", 9047 idx + 1, len, function, trim_filename (file), line); 9048 } 9049 9050 /* Similar to above, except that the check is for the bounds of the operand 9051 vector of an expression node EXP. */ 9052 9053 void 9054 tree_operand_check_failed (int idx, const_tree exp, const char *file, 9055 int line, const char *function) 9056 { 9057 int code = TREE_CODE (exp); 9058 internal_error 9059 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d", 9060 idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp), 9061 function, trim_filename (file), line); 9062 } 9063 9064 /* Similar to above, except that the check is for the number of 9065 operands of an OMP_CLAUSE node. */ 9066 9067 void 9068 omp_clause_operand_check_failed (int idx, const_tree t, const char *file, 9069 int line, const char *function) 9070 { 9071 internal_error 9072 ("tree check: accessed operand %d of omp_clause %s with %d operands " 9073 "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)], 9074 omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function, 9075 trim_filename (file), line); 9076 } 9077 #endif /* ENABLE_TREE_CHECKING */ 9078 9079 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE, 9080 and mapped to the machine mode MODE. Initialize its fields and build 9081 the information necessary for debugging output. */ 9082 9083 static tree 9084 make_vector_type (tree innertype, int nunits, enum machine_mode mode) 9085 { 9086 tree t; 9087 hashval_t hashcode = 0; 9088 9089 t = make_node (VECTOR_TYPE); 9090 TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype); 9091 SET_TYPE_VECTOR_SUBPARTS (t, nunits); 9092 SET_TYPE_MODE (t, mode); 9093 9094 if (TYPE_STRUCTURAL_EQUALITY_P (innertype)) 9095 SET_TYPE_STRUCTURAL_EQUALITY (t); 9096 else if (TYPE_CANONICAL (innertype) != innertype 9097 || mode != VOIDmode) 9098 TYPE_CANONICAL (t) 9099 = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode); 9100 9101 layout_type (t); 9102 9103 hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode); 9104 hashcode = iterative_hash_host_wide_int (nunits, hashcode); 9105 hashcode = iterative_hash_host_wide_int (mode, hashcode); 9106 hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode); 9107 t = type_hash_canon (hashcode, t); 9108 9109 /* We have built a main variant, based on the main variant of the 9110 inner type. Use it to build the variant we return. */ 9111 if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype)) 9112 && TREE_TYPE (t) != innertype) 9113 return build_type_attribute_qual_variant (t, 9114 TYPE_ATTRIBUTES (innertype), 9115 TYPE_QUALS (innertype)); 9116 9117 return t; 9118 } 9119 9120 static tree 9121 make_or_reuse_type (unsigned size, int unsignedp) 9122 { 9123 if (size == INT_TYPE_SIZE) 9124 return unsignedp ? unsigned_type_node : integer_type_node; 9125 if (size == CHAR_TYPE_SIZE) 9126 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 9127 if (size == SHORT_TYPE_SIZE) 9128 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 9129 if (size == LONG_TYPE_SIZE) 9130 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 9131 if (size == LONG_LONG_TYPE_SIZE) 9132 return (unsignedp ? long_long_unsigned_type_node 9133 : long_long_integer_type_node); 9134 if (size == 128 && int128_integer_type_node) 9135 return (unsignedp ? int128_unsigned_type_node 9136 : int128_integer_type_node); 9137 9138 if (unsignedp) 9139 return make_unsigned_type (size); 9140 else 9141 return make_signed_type (size); 9142 } 9143 9144 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */ 9145 9146 static tree 9147 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp) 9148 { 9149 if (satp) 9150 { 9151 if (size == SHORT_FRACT_TYPE_SIZE) 9152 return unsignedp ? sat_unsigned_short_fract_type_node 9153 : sat_short_fract_type_node; 9154 if (size == FRACT_TYPE_SIZE) 9155 return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node; 9156 if (size == LONG_FRACT_TYPE_SIZE) 9157 return unsignedp ? sat_unsigned_long_fract_type_node 9158 : sat_long_fract_type_node; 9159 if (size == LONG_LONG_FRACT_TYPE_SIZE) 9160 return unsignedp ? sat_unsigned_long_long_fract_type_node 9161 : sat_long_long_fract_type_node; 9162 } 9163 else 9164 { 9165 if (size == SHORT_FRACT_TYPE_SIZE) 9166 return unsignedp ? unsigned_short_fract_type_node 9167 : short_fract_type_node; 9168 if (size == FRACT_TYPE_SIZE) 9169 return unsignedp ? unsigned_fract_type_node : fract_type_node; 9170 if (size == LONG_FRACT_TYPE_SIZE) 9171 return unsignedp ? unsigned_long_fract_type_node 9172 : long_fract_type_node; 9173 if (size == LONG_LONG_FRACT_TYPE_SIZE) 9174 return unsignedp ? unsigned_long_long_fract_type_node 9175 : long_long_fract_type_node; 9176 } 9177 9178 return make_fract_type (size, unsignedp, satp); 9179 } 9180 9181 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */ 9182 9183 static tree 9184 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp) 9185 { 9186 if (satp) 9187 { 9188 if (size == SHORT_ACCUM_TYPE_SIZE) 9189 return unsignedp ? sat_unsigned_short_accum_type_node 9190 : sat_short_accum_type_node; 9191 if (size == ACCUM_TYPE_SIZE) 9192 return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node; 9193 if (size == LONG_ACCUM_TYPE_SIZE) 9194 return unsignedp ? sat_unsigned_long_accum_type_node 9195 : sat_long_accum_type_node; 9196 if (size == LONG_LONG_ACCUM_TYPE_SIZE) 9197 return unsignedp ? sat_unsigned_long_long_accum_type_node 9198 : sat_long_long_accum_type_node; 9199 } 9200 else 9201 { 9202 if (size == SHORT_ACCUM_TYPE_SIZE) 9203 return unsignedp ? unsigned_short_accum_type_node 9204 : short_accum_type_node; 9205 if (size == ACCUM_TYPE_SIZE) 9206 return unsignedp ? unsigned_accum_type_node : accum_type_node; 9207 if (size == LONG_ACCUM_TYPE_SIZE) 9208 return unsignedp ? unsigned_long_accum_type_node 9209 : long_accum_type_node; 9210 if (size == LONG_LONG_ACCUM_TYPE_SIZE) 9211 return unsignedp ? unsigned_long_long_accum_type_node 9212 : long_long_accum_type_node; 9213 } 9214 9215 return make_accum_type (size, unsignedp, satp); 9216 } 9217 9218 /* Create nodes for all integer types (and error_mark_node) using the sizes 9219 of C datatypes. SIGNED_CHAR specifies whether char is signed, 9220 SHORT_DOUBLE specifies whether double should be of the same precision 9221 as float. */ 9222 9223 void 9224 build_common_tree_nodes (bool signed_char, bool short_double) 9225 { 9226 error_mark_node = make_node (ERROR_MARK); 9227 TREE_TYPE (error_mark_node) = error_mark_node; 9228 9229 initialize_sizetypes (); 9230 9231 /* Define both `signed char' and `unsigned char'. */ 9232 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE); 9233 TYPE_STRING_FLAG (signed_char_type_node) = 1; 9234 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE); 9235 TYPE_STRING_FLAG (unsigned_char_type_node) = 1; 9236 9237 /* Define `char', which is like either `signed char' or `unsigned char' 9238 but not the same as either. */ 9239 char_type_node 9240 = (signed_char 9241 ? make_signed_type (CHAR_TYPE_SIZE) 9242 : make_unsigned_type (CHAR_TYPE_SIZE)); 9243 TYPE_STRING_FLAG (char_type_node) = 1; 9244 9245 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE); 9246 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE); 9247 integer_type_node = make_signed_type (INT_TYPE_SIZE); 9248 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE); 9249 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE); 9250 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE); 9251 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE); 9252 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE); 9253 #if HOST_BITS_PER_WIDE_INT >= 64 9254 /* TODO: This isn't correct, but as logic depends at the moment on 9255 host's instead of target's wide-integer. 9256 If there is a target not supporting TImode, but has an 128-bit 9257 integer-scalar register, this target check needs to be adjusted. */ 9258 if (targetm.scalar_mode_supported_p (TImode)) 9259 { 9260 int128_integer_type_node = make_signed_type (128); 9261 int128_unsigned_type_node = make_unsigned_type (128); 9262 } 9263 #endif 9264 9265 /* Define a boolean type. This type only represents boolean values but 9266 may be larger than char depending on the value of BOOL_TYPE_SIZE. 9267 Front ends which want to override this size (i.e. Java) can redefine 9268 boolean_type_node before calling build_common_tree_nodes_2. */ 9269 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE); 9270 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE); 9271 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1); 9272 TYPE_PRECISION (boolean_type_node) = 1; 9273 9274 /* Define what type to use for size_t. */ 9275 if (strcmp (SIZE_TYPE, "unsigned int") == 0) 9276 size_type_node = unsigned_type_node; 9277 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0) 9278 size_type_node = long_unsigned_type_node; 9279 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0) 9280 size_type_node = long_long_unsigned_type_node; 9281 else if (strcmp (SIZE_TYPE, "short unsigned int") == 0) 9282 size_type_node = short_unsigned_type_node; 9283 else 9284 gcc_unreachable (); 9285 9286 /* Fill in the rest of the sized types. Reuse existing type nodes 9287 when possible. */ 9288 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0); 9289 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0); 9290 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0); 9291 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0); 9292 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0); 9293 9294 unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1); 9295 unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1); 9296 unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1); 9297 unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1); 9298 unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1); 9299 9300 access_public_node = get_identifier ("public"); 9301 access_protected_node = get_identifier ("protected"); 9302 access_private_node = get_identifier ("private"); 9303 9304 /* Define these next since types below may used them. */ 9305 integer_zero_node = build_int_cst (integer_type_node, 0); 9306 integer_one_node = build_int_cst (integer_type_node, 1); 9307 integer_three_node = build_int_cst (integer_type_node, 3); 9308 integer_minus_one_node = build_int_cst (integer_type_node, -1); 9309 9310 size_zero_node = size_int (0); 9311 size_one_node = size_int (1); 9312 bitsize_zero_node = bitsize_int (0); 9313 bitsize_one_node = bitsize_int (1); 9314 bitsize_unit_node = bitsize_int (BITS_PER_UNIT); 9315 9316 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node); 9317 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node); 9318 9319 void_type_node = make_node (VOID_TYPE); 9320 layout_type (void_type_node); 9321 9322 /* We are not going to have real types in C with less than byte alignment, 9323 so we might as well not have any types that claim to have it. */ 9324 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT; 9325 TYPE_USER_ALIGN (void_type_node) = 0; 9326 9327 null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0); 9328 layout_type (TREE_TYPE (null_pointer_node)); 9329 9330 ptr_type_node = build_pointer_type (void_type_node); 9331 const_ptr_type_node 9332 = build_pointer_type (build_type_variant (void_type_node, 1, 0)); 9333 fileptr_type_node = ptr_type_node; 9334 9335 float_type_node = make_node (REAL_TYPE); 9336 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE; 9337 layout_type (float_type_node); 9338 9339 double_type_node = make_node (REAL_TYPE); 9340 if (short_double) 9341 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE; 9342 else 9343 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE; 9344 layout_type (double_type_node); 9345 9346 long_double_type_node = make_node (REAL_TYPE); 9347 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE; 9348 layout_type (long_double_type_node); 9349 9350 float_ptr_type_node = build_pointer_type (float_type_node); 9351 double_ptr_type_node = build_pointer_type (double_type_node); 9352 long_double_ptr_type_node = build_pointer_type (long_double_type_node); 9353 integer_ptr_type_node = build_pointer_type (integer_type_node); 9354 9355 /* Fixed size integer types. */ 9356 uint32_type_node = build_nonstandard_integer_type (32, true); 9357 uint64_type_node = build_nonstandard_integer_type (64, true); 9358 9359 /* Decimal float types. */ 9360 dfloat32_type_node = make_node (REAL_TYPE); 9361 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE; 9362 layout_type (dfloat32_type_node); 9363 SET_TYPE_MODE (dfloat32_type_node, SDmode); 9364 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node); 9365 9366 dfloat64_type_node = make_node (REAL_TYPE); 9367 TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE; 9368 layout_type (dfloat64_type_node); 9369 SET_TYPE_MODE (dfloat64_type_node, DDmode); 9370 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node); 9371 9372 dfloat128_type_node = make_node (REAL_TYPE); 9373 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE; 9374 layout_type (dfloat128_type_node); 9375 SET_TYPE_MODE (dfloat128_type_node, TDmode); 9376 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node); 9377 9378 complex_integer_type_node = build_complex_type (integer_type_node); 9379 complex_float_type_node = build_complex_type (float_type_node); 9380 complex_double_type_node = build_complex_type (double_type_node); 9381 complex_long_double_type_node = build_complex_type (long_double_type_node); 9382 9383 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */ 9384 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \ 9385 sat_ ## KIND ## _type_node = \ 9386 make_sat_signed_ ## KIND ## _type (SIZE); \ 9387 sat_unsigned_ ## KIND ## _type_node = \ 9388 make_sat_unsigned_ ## KIND ## _type (SIZE); \ 9389 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \ 9390 unsigned_ ## KIND ## _type_node = \ 9391 make_unsigned_ ## KIND ## _type (SIZE); 9392 9393 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \ 9394 sat_ ## WIDTH ## KIND ## _type_node = \ 9395 make_sat_signed_ ## KIND ## _type (SIZE); \ 9396 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \ 9397 make_sat_unsigned_ ## KIND ## _type (SIZE); \ 9398 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \ 9399 unsigned_ ## WIDTH ## KIND ## _type_node = \ 9400 make_unsigned_ ## KIND ## _type (SIZE); 9401 9402 /* Make fixed-point type nodes based on four different widths. */ 9403 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \ 9404 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \ 9405 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \ 9406 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \ 9407 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE) 9408 9409 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */ 9410 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \ 9411 NAME ## _type_node = \ 9412 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \ 9413 u ## NAME ## _type_node = \ 9414 make_or_reuse_unsigned_ ## KIND ## _type \ 9415 (GET_MODE_BITSIZE (U ## MODE ## mode)); \ 9416 sat_ ## NAME ## _type_node = \ 9417 make_or_reuse_sat_signed_ ## KIND ## _type \ 9418 (GET_MODE_BITSIZE (MODE ## mode)); \ 9419 sat_u ## NAME ## _type_node = \ 9420 make_or_reuse_sat_unsigned_ ## KIND ## _type \ 9421 (GET_MODE_BITSIZE (U ## MODE ## mode)); 9422 9423 /* Fixed-point type and mode nodes. */ 9424 MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT) 9425 MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM) 9426 MAKE_FIXED_MODE_NODE (fract, qq, QQ) 9427 MAKE_FIXED_MODE_NODE (fract, hq, HQ) 9428 MAKE_FIXED_MODE_NODE (fract, sq, SQ) 9429 MAKE_FIXED_MODE_NODE (fract, dq, DQ) 9430 MAKE_FIXED_MODE_NODE (fract, tq, TQ) 9431 MAKE_FIXED_MODE_NODE (accum, ha, HA) 9432 MAKE_FIXED_MODE_NODE (accum, sa, SA) 9433 MAKE_FIXED_MODE_NODE (accum, da, DA) 9434 MAKE_FIXED_MODE_NODE (accum, ta, TA) 9435 9436 { 9437 tree t = targetm.build_builtin_va_list (); 9438 9439 /* Many back-ends define record types without setting TYPE_NAME. 9440 If we copied the record type here, we'd keep the original 9441 record type without a name. This breaks name mangling. So, 9442 don't copy record types and let c_common_nodes_and_builtins() 9443 declare the type to be __builtin_va_list. */ 9444 if (TREE_CODE (t) != RECORD_TYPE) 9445 t = build_variant_type_copy (t); 9446 9447 va_list_type_node = t; 9448 } 9449 } 9450 9451 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */ 9452 9453 static void 9454 local_define_builtin (const char *name, tree type, enum built_in_function code, 9455 const char *library_name, int ecf_flags) 9456 { 9457 tree decl; 9458 9459 decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL, 9460 library_name, NULL_TREE); 9461 if (ecf_flags & ECF_CONST) 9462 TREE_READONLY (decl) = 1; 9463 if (ecf_flags & ECF_PURE) 9464 DECL_PURE_P (decl) = 1; 9465 if (ecf_flags & ECF_LOOPING_CONST_OR_PURE) 9466 DECL_LOOPING_CONST_OR_PURE_P (decl) = 1; 9467 if (ecf_flags & ECF_NORETURN) 9468 TREE_THIS_VOLATILE (decl) = 1; 9469 if (ecf_flags & ECF_NOTHROW) 9470 TREE_NOTHROW (decl) = 1; 9471 if (ecf_flags & ECF_MALLOC) 9472 DECL_IS_MALLOC (decl) = 1; 9473 if (ecf_flags & ECF_LEAF) 9474 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"), 9475 NULL, DECL_ATTRIBUTES (decl)); 9476 if ((ecf_flags & ECF_TM_PURE) && flag_tm) 9477 apply_tm_attr (decl, get_identifier ("transaction_pure")); 9478 9479 set_builtin_decl (code, decl, true); 9480 } 9481 9482 /* Call this function after instantiating all builtins that the language 9483 front end cares about. This will build the rest of the builtins that 9484 are relied upon by the tree optimizers and the middle-end. */ 9485 9486 void 9487 build_common_builtin_nodes (void) 9488 { 9489 tree tmp, ftype; 9490 int ecf_flags; 9491 9492 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY) 9493 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE)) 9494 { 9495 ftype = build_function_type_list (ptr_type_node, 9496 ptr_type_node, const_ptr_type_node, 9497 size_type_node, NULL_TREE); 9498 9499 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)) 9500 local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY, 9501 "memcpy", ECF_NOTHROW | ECF_LEAF); 9502 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE)) 9503 local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE, 9504 "memmove", ECF_NOTHROW | ECF_LEAF); 9505 } 9506 9507 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP)) 9508 { 9509 ftype = build_function_type_list (integer_type_node, const_ptr_type_node, 9510 const_ptr_type_node, size_type_node, 9511 NULL_TREE); 9512 local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP, 9513 "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF); 9514 } 9515 9516 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET)) 9517 { 9518 ftype = build_function_type_list (ptr_type_node, 9519 ptr_type_node, integer_type_node, 9520 size_type_node, NULL_TREE); 9521 local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET, 9522 "memset", ECF_NOTHROW | ECF_LEAF); 9523 } 9524 9525 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA)) 9526 { 9527 ftype = build_function_type_list (ptr_type_node, 9528 size_type_node, NULL_TREE); 9529 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA, 9530 "alloca", ECF_MALLOC | ECF_NOTHROW | ECF_LEAF); 9531 } 9532 9533 ftype = build_function_type_list (ptr_type_node, size_type_node, 9534 size_type_node, NULL_TREE); 9535 local_define_builtin ("__builtin_alloca_with_align", ftype, 9536 BUILT_IN_ALLOCA_WITH_ALIGN, "alloca", 9537 ECF_MALLOC | ECF_NOTHROW | ECF_LEAF); 9538 9539 /* If we're checking the stack, `alloca' can throw. */ 9540 if (flag_stack_check) 9541 { 9542 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA)) = 0; 9543 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN)) = 0; 9544 } 9545 9546 ftype = build_function_type_list (void_type_node, 9547 ptr_type_node, ptr_type_node, 9548 ptr_type_node, NULL_TREE); 9549 local_define_builtin ("__builtin_init_trampoline", ftype, 9550 BUILT_IN_INIT_TRAMPOLINE, 9551 "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF); 9552 local_define_builtin ("__builtin_init_heap_trampoline", ftype, 9553 BUILT_IN_INIT_HEAP_TRAMPOLINE, 9554 "__builtin_init_heap_trampoline", 9555 ECF_NOTHROW | ECF_LEAF); 9556 9557 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE); 9558 local_define_builtin ("__builtin_adjust_trampoline", ftype, 9559 BUILT_IN_ADJUST_TRAMPOLINE, 9560 "__builtin_adjust_trampoline", 9561 ECF_CONST | ECF_NOTHROW); 9562 9563 ftype = build_function_type_list (void_type_node, 9564 ptr_type_node, ptr_type_node, NULL_TREE); 9565 local_define_builtin ("__builtin_nonlocal_goto", ftype, 9566 BUILT_IN_NONLOCAL_GOTO, 9567 "__builtin_nonlocal_goto", 9568 ECF_NORETURN | ECF_NOTHROW); 9569 9570 ftype = build_function_type_list (void_type_node, 9571 ptr_type_node, ptr_type_node, NULL_TREE); 9572 local_define_builtin ("__builtin_setjmp_setup", ftype, 9573 BUILT_IN_SETJMP_SETUP, 9574 "__builtin_setjmp_setup", ECF_NOTHROW); 9575 9576 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE); 9577 local_define_builtin ("__builtin_setjmp_dispatcher", ftype, 9578 BUILT_IN_SETJMP_DISPATCHER, 9579 "__builtin_setjmp_dispatcher", 9580 ECF_PURE | ECF_NOTHROW); 9581 9582 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE); 9583 local_define_builtin ("__builtin_setjmp_receiver", ftype, 9584 BUILT_IN_SETJMP_RECEIVER, 9585 "__builtin_setjmp_receiver", ECF_NOTHROW); 9586 9587 ftype = build_function_type_list (ptr_type_node, NULL_TREE); 9588 local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE, 9589 "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF); 9590 9591 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE); 9592 local_define_builtin ("__builtin_stack_restore", ftype, 9593 BUILT_IN_STACK_RESTORE, 9594 "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF); 9595 9596 /* If there's a possibility that we might use the ARM EABI, build the 9597 alternate __cxa_end_cleanup node used to resume from C++ and Java. */ 9598 if (targetm.arm_eabi_unwinder) 9599 { 9600 ftype = build_function_type_list (void_type_node, NULL_TREE); 9601 local_define_builtin ("__builtin_cxa_end_cleanup", ftype, 9602 BUILT_IN_CXA_END_CLEANUP, 9603 "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF); 9604 } 9605 9606 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE); 9607 local_define_builtin ("__builtin_unwind_resume", ftype, 9608 BUILT_IN_UNWIND_RESUME, 9609 ((targetm_common.except_unwind_info (&global_options) 9610 == UI_SJLJ) 9611 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"), 9612 ECF_NORETURN); 9613 9614 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE) 9615 { 9616 ftype = build_function_type_list (ptr_type_node, integer_type_node, 9617 NULL_TREE); 9618 local_define_builtin ("__builtin_return_address", ftype, 9619 BUILT_IN_RETURN_ADDRESS, 9620 "__builtin_return_address", 9621 ECF_NOTHROW); 9622 } 9623 9624 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER) 9625 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT)) 9626 { 9627 ftype = build_function_type_list (void_type_node, ptr_type_node, 9628 ptr_type_node, NULL_TREE); 9629 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)) 9630 local_define_builtin ("__cyg_profile_func_enter", ftype, 9631 BUILT_IN_PROFILE_FUNC_ENTER, 9632 "__cyg_profile_func_enter", 0); 9633 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT)) 9634 local_define_builtin ("__cyg_profile_func_exit", ftype, 9635 BUILT_IN_PROFILE_FUNC_EXIT, 9636 "__cyg_profile_func_exit", 0); 9637 } 9638 9639 /* The exception object and filter values from the runtime. The argument 9640 must be zero before exception lowering, i.e. from the front end. After 9641 exception lowering, it will be the region number for the exception 9642 landing pad. These functions are PURE instead of CONST to prevent 9643 them from being hoisted past the exception edge that will initialize 9644 its value in the landing pad. */ 9645 ftype = build_function_type_list (ptr_type_node, 9646 integer_type_node, NULL_TREE); 9647 ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF; 9648 /* Only use TM_PURE if we we have TM language support. */ 9649 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1)) 9650 ecf_flags |= ECF_TM_PURE; 9651 local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER, 9652 "__builtin_eh_pointer", ecf_flags); 9653 9654 tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0); 9655 ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE); 9656 local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER, 9657 "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF); 9658 9659 ftype = build_function_type_list (void_type_node, 9660 integer_type_node, integer_type_node, 9661 NULL_TREE); 9662 local_define_builtin ("__builtin_eh_copy_values", ftype, 9663 BUILT_IN_EH_COPY_VALUES, 9664 "__builtin_eh_copy_values", ECF_NOTHROW); 9665 9666 /* Complex multiplication and division. These are handled as builtins 9667 rather than optabs because emit_library_call_value doesn't support 9668 complex. Further, we can do slightly better with folding these 9669 beasties if the real and complex parts of the arguments are separate. */ 9670 { 9671 int mode; 9672 9673 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode) 9674 { 9675 char mode_name_buf[4], *q; 9676 const char *p; 9677 enum built_in_function mcode, dcode; 9678 tree type, inner_type; 9679 const char *prefix = "__"; 9680 9681 if (targetm.libfunc_gnu_prefix) 9682 prefix = "__gnu_"; 9683 9684 type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0); 9685 if (type == NULL) 9686 continue; 9687 inner_type = TREE_TYPE (type); 9688 9689 ftype = build_function_type_list (type, inner_type, inner_type, 9690 inner_type, inner_type, NULL_TREE); 9691 9692 mcode = ((enum built_in_function) 9693 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT)); 9694 dcode = ((enum built_in_function) 9695 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT)); 9696 9697 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++) 9698 *q = TOLOWER (*p); 9699 *q = '\0'; 9700 9701 built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3", 9702 NULL); 9703 local_define_builtin (built_in_names[mcode], ftype, mcode, 9704 built_in_names[mcode], 9705 ECF_CONST | ECF_NOTHROW | ECF_LEAF); 9706 9707 built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3", 9708 NULL); 9709 local_define_builtin (built_in_names[dcode], ftype, dcode, 9710 built_in_names[dcode], 9711 ECF_CONST | ECF_NOTHROW | ECF_LEAF); 9712 } 9713 } 9714 } 9715 9716 /* HACK. GROSS. This is absolutely disgusting. I wish there was a 9717 better way. 9718 9719 If we requested a pointer to a vector, build up the pointers that 9720 we stripped off while looking for the inner type. Similarly for 9721 return values from functions. 9722 9723 The argument TYPE is the top of the chain, and BOTTOM is the 9724 new type which we will point to. */ 9725 9726 tree 9727 reconstruct_complex_type (tree type, tree bottom) 9728 { 9729 tree inner, outer; 9730 9731 if (TREE_CODE (type) == POINTER_TYPE) 9732 { 9733 inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 9734 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type), 9735 TYPE_REF_CAN_ALIAS_ALL (type)); 9736 } 9737 else if (TREE_CODE (type) == REFERENCE_TYPE) 9738 { 9739 inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 9740 outer = build_reference_type_for_mode (inner, TYPE_MODE (type), 9741 TYPE_REF_CAN_ALIAS_ALL (type)); 9742 } 9743 else if (TREE_CODE (type) == ARRAY_TYPE) 9744 { 9745 inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 9746 outer = build_array_type (inner, TYPE_DOMAIN (type)); 9747 } 9748 else if (TREE_CODE (type) == FUNCTION_TYPE) 9749 { 9750 inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 9751 outer = build_function_type (inner, TYPE_ARG_TYPES (type)); 9752 } 9753 else if (TREE_CODE (type) == METHOD_TYPE) 9754 { 9755 inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 9756 /* The build_method_type_directly() routine prepends 'this' to argument list, 9757 so we must compensate by getting rid of it. */ 9758 outer 9759 = build_method_type_directly 9760 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))), 9761 inner, 9762 TREE_CHAIN (TYPE_ARG_TYPES (type))); 9763 } 9764 else if (TREE_CODE (type) == OFFSET_TYPE) 9765 { 9766 inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 9767 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner); 9768 } 9769 else 9770 return bottom; 9771 9772 return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type), 9773 TYPE_QUALS (type)); 9774 } 9775 9776 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and 9777 the inner type. */ 9778 tree 9779 build_vector_type_for_mode (tree innertype, enum machine_mode mode) 9780 { 9781 int nunits; 9782 9783 switch (GET_MODE_CLASS (mode)) 9784 { 9785 case MODE_VECTOR_INT: 9786 case MODE_VECTOR_FLOAT: 9787 case MODE_VECTOR_FRACT: 9788 case MODE_VECTOR_UFRACT: 9789 case MODE_VECTOR_ACCUM: 9790 case MODE_VECTOR_UACCUM: 9791 nunits = GET_MODE_NUNITS (mode); 9792 break; 9793 9794 case MODE_INT: 9795 /* Check that there are no leftover bits. */ 9796 gcc_assert (GET_MODE_BITSIZE (mode) 9797 % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0); 9798 9799 nunits = GET_MODE_BITSIZE (mode) 9800 / TREE_INT_CST_LOW (TYPE_SIZE (innertype)); 9801 break; 9802 9803 default: 9804 gcc_unreachable (); 9805 } 9806 9807 return make_vector_type (innertype, nunits, mode); 9808 } 9809 9810 /* Similarly, but takes the inner type and number of units, which must be 9811 a power of two. */ 9812 9813 tree 9814 build_vector_type (tree innertype, int nunits) 9815 { 9816 return make_vector_type (innertype, nunits, VOIDmode); 9817 } 9818 9819 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */ 9820 9821 tree 9822 build_opaque_vector_type (tree innertype, int nunits) 9823 { 9824 tree t = make_vector_type (innertype, nunits, VOIDmode); 9825 tree cand; 9826 /* We always build the non-opaque variant before the opaque one, 9827 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */ 9828 cand = TYPE_NEXT_VARIANT (t); 9829 if (cand 9830 && TYPE_VECTOR_OPAQUE (cand) 9831 && check_qualified_type (cand, t, TYPE_QUALS (t))) 9832 return cand; 9833 /* Othewise build a variant type and make sure to queue it after 9834 the non-opaque type. */ 9835 cand = build_distinct_type_copy (t); 9836 TYPE_VECTOR_OPAQUE (cand) = true; 9837 TYPE_CANONICAL (cand) = TYPE_CANONICAL (t); 9838 TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t); 9839 TYPE_NEXT_VARIANT (t) = cand; 9840 TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t); 9841 return cand; 9842 } 9843 9844 9845 /* Given an initializer INIT, return TRUE if INIT is zero or some 9846 aggregate of zeros. Otherwise return FALSE. */ 9847 bool 9848 initializer_zerop (const_tree init) 9849 { 9850 tree elt; 9851 9852 STRIP_NOPS (init); 9853 9854 switch (TREE_CODE (init)) 9855 { 9856 case INTEGER_CST: 9857 return integer_zerop (init); 9858 9859 case REAL_CST: 9860 /* ??? Note that this is not correct for C4X float formats. There, 9861 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most 9862 negative exponent. */ 9863 return real_zerop (init) 9864 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init)); 9865 9866 case FIXED_CST: 9867 return fixed_zerop (init); 9868 9869 case COMPLEX_CST: 9870 return integer_zerop (init) 9871 || (real_zerop (init) 9872 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init))) 9873 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init)))); 9874 9875 case VECTOR_CST: 9876 for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt)) 9877 if (!initializer_zerop (TREE_VALUE (elt))) 9878 return false; 9879 return true; 9880 9881 case CONSTRUCTOR: 9882 { 9883 unsigned HOST_WIDE_INT idx; 9884 9885 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt) 9886 if (!initializer_zerop (elt)) 9887 return false; 9888 return true; 9889 } 9890 9891 case STRING_CST: 9892 { 9893 int i; 9894 9895 /* We need to loop through all elements to handle cases like 9896 "\0" and "\0foobar". */ 9897 for (i = 0; i < TREE_STRING_LENGTH (init); ++i) 9898 if (TREE_STRING_POINTER (init)[i] != '\0') 9899 return false; 9900 9901 return true; 9902 } 9903 9904 default: 9905 return false; 9906 } 9907 } 9908 9909 /* Build an empty statement at location LOC. */ 9910 9911 tree 9912 build_empty_stmt (location_t loc) 9913 { 9914 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node); 9915 SET_EXPR_LOCATION (t, loc); 9916 return t; 9917 } 9918 9919 9920 /* Build an OpenMP clause with code CODE. LOC is the location of the 9921 clause. */ 9922 9923 tree 9924 build_omp_clause (location_t loc, enum omp_clause_code code) 9925 { 9926 tree t; 9927 int size, length; 9928 9929 length = omp_clause_num_ops[code]; 9930 size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree)); 9931 9932 record_node_allocation_statistics (OMP_CLAUSE, size); 9933 9934 t = ggc_alloc_tree_node (size); 9935 memset (t, 0, size); 9936 TREE_SET_CODE (t, OMP_CLAUSE); 9937 OMP_CLAUSE_SET_CODE (t, code); 9938 OMP_CLAUSE_LOCATION (t) = loc; 9939 9940 return t; 9941 } 9942 9943 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN 9944 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1. 9945 Except for the CODE and operand count field, other storage for the 9946 object is initialized to zeros. */ 9947 9948 tree 9949 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL) 9950 { 9951 tree t; 9952 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp); 9953 9954 gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp); 9955 gcc_assert (len >= 1); 9956 9957 record_node_allocation_statistics (code, length); 9958 9959 t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT); 9960 9961 TREE_SET_CODE (t, code); 9962 9963 /* Can't use TREE_OPERAND to store the length because if checking is 9964 enabled, it will try to check the length before we store it. :-P */ 9965 t->exp.operands[0] = build_int_cst (sizetype, len); 9966 9967 return t; 9968 } 9969 9970 /* Helper function for build_call_* functions; build a CALL_EXPR with 9971 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of 9972 the argument slots. */ 9973 9974 static tree 9975 build_call_1 (tree return_type, tree fn, int nargs) 9976 { 9977 tree t; 9978 9979 t = build_vl_exp (CALL_EXPR, nargs + 3); 9980 TREE_TYPE (t) = return_type; 9981 CALL_EXPR_FN (t) = fn; 9982 CALL_EXPR_STATIC_CHAIN (t) = NULL; 9983 9984 return t; 9985 } 9986 9987 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and 9988 FN and a null static chain slot. NARGS is the number of call arguments 9989 which are specified as "..." arguments. */ 9990 9991 tree 9992 build_call_nary (tree return_type, tree fn, int nargs, ...) 9993 { 9994 tree ret; 9995 va_list args; 9996 va_start (args, nargs); 9997 ret = build_call_valist (return_type, fn, nargs, args); 9998 va_end (args); 9999 return ret; 10000 } 10001 10002 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and 10003 FN and a null static chain slot. NARGS is the number of call arguments 10004 which are specified as a va_list ARGS. */ 10005 10006 tree 10007 build_call_valist (tree return_type, tree fn, int nargs, va_list args) 10008 { 10009 tree t; 10010 int i; 10011 10012 t = build_call_1 (return_type, fn, nargs); 10013 for (i = 0; i < nargs; i++) 10014 CALL_EXPR_ARG (t, i) = va_arg (args, tree); 10015 process_call_operands (t); 10016 return t; 10017 } 10018 10019 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and 10020 FN and a null static chain slot. NARGS is the number of call arguments 10021 which are specified as a tree array ARGS. */ 10022 10023 tree 10024 build_call_array_loc (location_t loc, tree return_type, tree fn, 10025 int nargs, const tree *args) 10026 { 10027 tree t; 10028 int i; 10029 10030 t = build_call_1 (return_type, fn, nargs); 10031 for (i = 0; i < nargs; i++) 10032 CALL_EXPR_ARG (t, i) = args[i]; 10033 process_call_operands (t); 10034 SET_EXPR_LOCATION (t, loc); 10035 return t; 10036 } 10037 10038 /* Like build_call_array, but takes a VEC. */ 10039 10040 tree 10041 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args) 10042 { 10043 tree ret, t; 10044 unsigned int ix; 10045 10046 ret = build_call_1 (return_type, fn, VEC_length (tree, args)); 10047 FOR_EACH_VEC_ELT (tree, args, ix, t) 10048 CALL_EXPR_ARG (ret, ix) = t; 10049 process_call_operands (ret); 10050 return ret; 10051 } 10052 10053 10054 /* Returns true if it is possible to prove that the index of 10055 an array access REF (an ARRAY_REF expression) falls into the 10056 array bounds. */ 10057 10058 bool 10059 in_array_bounds_p (tree ref) 10060 { 10061 tree idx = TREE_OPERAND (ref, 1); 10062 tree min, max; 10063 10064 if (TREE_CODE (idx) != INTEGER_CST) 10065 return false; 10066 10067 min = array_ref_low_bound (ref); 10068 max = array_ref_up_bound (ref); 10069 if (!min 10070 || !max 10071 || TREE_CODE (min) != INTEGER_CST 10072 || TREE_CODE (max) != INTEGER_CST) 10073 return false; 10074 10075 if (tree_int_cst_lt (idx, min) 10076 || tree_int_cst_lt (max, idx)) 10077 return false; 10078 10079 return true; 10080 } 10081 10082 /* Returns true if it is possible to prove that the range of 10083 an array access REF (an ARRAY_RANGE_REF expression) falls 10084 into the array bounds. */ 10085 10086 bool 10087 range_in_array_bounds_p (tree ref) 10088 { 10089 tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref)); 10090 tree range_min, range_max, min, max; 10091 10092 range_min = TYPE_MIN_VALUE (domain_type); 10093 range_max = TYPE_MAX_VALUE (domain_type); 10094 if (!range_min 10095 || !range_max 10096 || TREE_CODE (range_min) != INTEGER_CST 10097 || TREE_CODE (range_max) != INTEGER_CST) 10098 return false; 10099 10100 min = array_ref_low_bound (ref); 10101 max = array_ref_up_bound (ref); 10102 if (!min 10103 || !max 10104 || TREE_CODE (min) != INTEGER_CST 10105 || TREE_CODE (max) != INTEGER_CST) 10106 return false; 10107 10108 if (tree_int_cst_lt (range_min, min) 10109 || tree_int_cst_lt (max, range_max)) 10110 return false; 10111 10112 return true; 10113 } 10114 10115 /* Return true if T (assumed to be a DECL) must be assigned a memory 10116 location. */ 10117 10118 bool 10119 needs_to_live_in_memory (const_tree t) 10120 { 10121 if (TREE_CODE (t) == SSA_NAME) 10122 t = SSA_NAME_VAR (t); 10123 10124 return (TREE_ADDRESSABLE (t) 10125 || is_global_var (t) 10126 || (TREE_CODE (t) == RESULT_DECL 10127 && !DECL_BY_REFERENCE (t) 10128 && aggregate_value_p (t, current_function_decl))); 10129 } 10130 10131 /* Return value of a constant X and sign-extend it. */ 10132 10133 HOST_WIDE_INT 10134 int_cst_value (const_tree x) 10135 { 10136 unsigned bits = TYPE_PRECISION (TREE_TYPE (x)); 10137 unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x); 10138 10139 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */ 10140 gcc_assert (TREE_INT_CST_HIGH (x) == 0 10141 || TREE_INT_CST_HIGH (x) == -1); 10142 10143 if (bits < HOST_BITS_PER_WIDE_INT) 10144 { 10145 bool negative = ((val >> (bits - 1)) & 1) != 0; 10146 if (negative) 10147 val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1; 10148 else 10149 val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1); 10150 } 10151 10152 return val; 10153 } 10154 10155 /* Return value of a constant X and sign-extend it. */ 10156 10157 HOST_WIDEST_INT 10158 widest_int_cst_value (const_tree x) 10159 { 10160 unsigned bits = TYPE_PRECISION (TREE_TYPE (x)); 10161 unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x); 10162 10163 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT 10164 gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT); 10165 val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x)) 10166 << HOST_BITS_PER_WIDE_INT); 10167 #else 10168 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */ 10169 gcc_assert (TREE_INT_CST_HIGH (x) == 0 10170 || TREE_INT_CST_HIGH (x) == -1); 10171 #endif 10172 10173 if (bits < HOST_BITS_PER_WIDEST_INT) 10174 { 10175 bool negative = ((val >> (bits - 1)) & 1) != 0; 10176 if (negative) 10177 val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1; 10178 else 10179 val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1); 10180 } 10181 10182 return val; 10183 } 10184 10185 /* If TYPE is an integral type, return an equivalent type which is 10186 unsigned iff UNSIGNEDP is true. If TYPE is not an integral type, 10187 return TYPE itself. */ 10188 10189 tree 10190 signed_or_unsigned_type_for (int unsignedp, tree type) 10191 { 10192 tree t = type; 10193 if (POINTER_TYPE_P (type)) 10194 { 10195 /* If the pointer points to the normal address space, use the 10196 size_type_node. Otherwise use an appropriate size for the pointer 10197 based on the named address space it points to. */ 10198 if (!TYPE_ADDR_SPACE (TREE_TYPE (t))) 10199 t = size_type_node; 10200 else 10201 return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp); 10202 } 10203 10204 if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp) 10205 return t; 10206 10207 return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp); 10208 } 10209 10210 /* Returns unsigned variant of TYPE. */ 10211 10212 tree 10213 unsigned_type_for (tree type) 10214 { 10215 return signed_or_unsigned_type_for (1, type); 10216 } 10217 10218 /* Returns signed variant of TYPE. */ 10219 10220 tree 10221 signed_type_for (tree type) 10222 { 10223 return signed_or_unsigned_type_for (0, type); 10224 } 10225 10226 /* Returns the largest value obtainable by casting something in INNER type to 10227 OUTER type. */ 10228 10229 tree 10230 upper_bound_in_type (tree outer, tree inner) 10231 { 10232 double_int high; 10233 unsigned int det = 0; 10234 unsigned oprec = TYPE_PRECISION (outer); 10235 unsigned iprec = TYPE_PRECISION (inner); 10236 unsigned prec; 10237 10238 /* Compute a unique number for every combination. */ 10239 det |= (oprec > iprec) ? 4 : 0; 10240 det |= TYPE_UNSIGNED (outer) ? 2 : 0; 10241 det |= TYPE_UNSIGNED (inner) ? 1 : 0; 10242 10243 /* Determine the exponent to use. */ 10244 switch (det) 10245 { 10246 case 0: 10247 case 1: 10248 /* oprec <= iprec, outer: signed, inner: don't care. */ 10249 prec = oprec - 1; 10250 break; 10251 case 2: 10252 case 3: 10253 /* oprec <= iprec, outer: unsigned, inner: don't care. */ 10254 prec = oprec; 10255 break; 10256 case 4: 10257 /* oprec > iprec, outer: signed, inner: signed. */ 10258 prec = iprec - 1; 10259 break; 10260 case 5: 10261 /* oprec > iprec, outer: signed, inner: unsigned. */ 10262 prec = iprec; 10263 break; 10264 case 6: 10265 /* oprec > iprec, outer: unsigned, inner: signed. */ 10266 prec = oprec; 10267 break; 10268 case 7: 10269 /* oprec > iprec, outer: unsigned, inner: unsigned. */ 10270 prec = iprec; 10271 break; 10272 default: 10273 gcc_unreachable (); 10274 } 10275 10276 /* Compute 2^^prec - 1. */ 10277 if (prec <= HOST_BITS_PER_WIDE_INT) 10278 { 10279 high.high = 0; 10280 high.low = ((~(unsigned HOST_WIDE_INT) 0) 10281 >> (HOST_BITS_PER_WIDE_INT - prec)); 10282 } 10283 else 10284 { 10285 high.high = ((~(unsigned HOST_WIDE_INT) 0) 10286 >> (2 * HOST_BITS_PER_WIDE_INT - prec)); 10287 high.low = ~(unsigned HOST_WIDE_INT) 0; 10288 } 10289 10290 return double_int_to_tree (outer, high); 10291 } 10292 10293 /* Returns the smallest value obtainable by casting something in INNER type to 10294 OUTER type. */ 10295 10296 tree 10297 lower_bound_in_type (tree outer, tree inner) 10298 { 10299 double_int low; 10300 unsigned oprec = TYPE_PRECISION (outer); 10301 unsigned iprec = TYPE_PRECISION (inner); 10302 10303 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type 10304 and obtain 0. */ 10305 if (TYPE_UNSIGNED (outer) 10306 /* If we are widening something of an unsigned type, OUTER type 10307 contains all values of INNER type. In particular, both INNER 10308 and OUTER types have zero in common. */ 10309 || (oprec > iprec && TYPE_UNSIGNED (inner))) 10310 low.low = low.high = 0; 10311 else 10312 { 10313 /* If we are widening a signed type to another signed type, we 10314 want to obtain -2^^(iprec-1). If we are keeping the 10315 precision or narrowing to a signed type, we want to obtain 10316 -2^(oprec-1). */ 10317 unsigned prec = oprec > iprec ? iprec : oprec; 10318 10319 if (prec <= HOST_BITS_PER_WIDE_INT) 10320 { 10321 low.high = ~(unsigned HOST_WIDE_INT) 0; 10322 low.low = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1); 10323 } 10324 else 10325 { 10326 low.high = ((~(unsigned HOST_WIDE_INT) 0) 10327 << (prec - HOST_BITS_PER_WIDE_INT - 1)); 10328 low.low = 0; 10329 } 10330 } 10331 10332 return double_int_to_tree (outer, low); 10333 } 10334 10335 /* Return nonzero if two operands that are suitable for PHI nodes are 10336 necessarily equal. Specifically, both ARG0 and ARG1 must be either 10337 SSA_NAME or invariant. Note that this is strictly an optimization. 10338 That is, callers of this function can directly call operand_equal_p 10339 and get the same result, only slower. */ 10340 10341 int 10342 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1) 10343 { 10344 if (arg0 == arg1) 10345 return 1; 10346 if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME) 10347 return 0; 10348 return operand_equal_p (arg0, arg1, 0); 10349 } 10350 10351 /* Returns number of zeros at the end of binary representation of X. 10352 10353 ??? Use ffs if available? */ 10354 10355 tree 10356 num_ending_zeros (const_tree x) 10357 { 10358 unsigned HOST_WIDE_INT fr, nfr; 10359 unsigned num, abits; 10360 tree type = TREE_TYPE (x); 10361 10362 if (TREE_INT_CST_LOW (x) == 0) 10363 { 10364 num = HOST_BITS_PER_WIDE_INT; 10365 fr = TREE_INT_CST_HIGH (x); 10366 } 10367 else 10368 { 10369 num = 0; 10370 fr = TREE_INT_CST_LOW (x); 10371 } 10372 10373 for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2) 10374 { 10375 nfr = fr >> abits; 10376 if (nfr << abits == fr) 10377 { 10378 num += abits; 10379 fr = nfr; 10380 } 10381 } 10382 10383 if (num > TYPE_PRECISION (type)) 10384 num = TYPE_PRECISION (type); 10385 10386 return build_int_cst_type (type, num); 10387 } 10388 10389 10390 #define WALK_SUBTREE(NODE) \ 10391 do \ 10392 { \ 10393 result = walk_tree_1 (&(NODE), func, data, pset, lh); \ 10394 if (result) \ 10395 return result; \ 10396 } \ 10397 while (0) 10398 10399 /* This is a subroutine of walk_tree that walks field of TYPE that are to 10400 be walked whenever a type is seen in the tree. Rest of operands and return 10401 value are as for walk_tree. */ 10402 10403 static tree 10404 walk_type_fields (tree type, walk_tree_fn func, void *data, 10405 struct pointer_set_t *pset, walk_tree_lh lh) 10406 { 10407 tree result = NULL_TREE; 10408 10409 switch (TREE_CODE (type)) 10410 { 10411 case POINTER_TYPE: 10412 case REFERENCE_TYPE: 10413 /* We have to worry about mutually recursive pointers. These can't 10414 be written in C. They can in Ada. It's pathological, but 10415 there's an ACATS test (c38102a) that checks it. Deal with this 10416 by checking if we're pointing to another pointer, that one 10417 points to another pointer, that one does too, and we have no htab. 10418 If so, get a hash table. We check three levels deep to avoid 10419 the cost of the hash table if we don't need one. */ 10420 if (POINTER_TYPE_P (TREE_TYPE (type)) 10421 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type))) 10422 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type)))) 10423 && !pset) 10424 { 10425 result = walk_tree_without_duplicates (&TREE_TYPE (type), 10426 func, data); 10427 if (result) 10428 return result; 10429 10430 break; 10431 } 10432 10433 /* ... fall through ... */ 10434 10435 case COMPLEX_TYPE: 10436 WALK_SUBTREE (TREE_TYPE (type)); 10437 break; 10438 10439 case METHOD_TYPE: 10440 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type)); 10441 10442 /* Fall through. */ 10443 10444 case FUNCTION_TYPE: 10445 WALK_SUBTREE (TREE_TYPE (type)); 10446 { 10447 tree arg; 10448 10449 /* We never want to walk into default arguments. */ 10450 for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg)) 10451 WALK_SUBTREE (TREE_VALUE (arg)); 10452 } 10453 break; 10454 10455 case ARRAY_TYPE: 10456 /* Don't follow this nodes's type if a pointer for fear that 10457 we'll have infinite recursion. If we have a PSET, then we 10458 need not fear. */ 10459 if (pset 10460 || (!POINTER_TYPE_P (TREE_TYPE (type)) 10461 && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE)) 10462 WALK_SUBTREE (TREE_TYPE (type)); 10463 WALK_SUBTREE (TYPE_DOMAIN (type)); 10464 break; 10465 10466 case OFFSET_TYPE: 10467 WALK_SUBTREE (TREE_TYPE (type)); 10468 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type)); 10469 break; 10470 10471 default: 10472 break; 10473 } 10474 10475 return NULL_TREE; 10476 } 10477 10478 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is 10479 called with the DATA and the address of each sub-tree. If FUNC returns a 10480 non-NULL value, the traversal is stopped, and the value returned by FUNC 10481 is returned. If PSET is non-NULL it is used to record the nodes visited, 10482 and to avoid visiting a node more than once. */ 10483 10484 tree 10485 walk_tree_1 (tree *tp, walk_tree_fn func, void *data, 10486 struct pointer_set_t *pset, walk_tree_lh lh) 10487 { 10488 enum tree_code code; 10489 int walk_subtrees; 10490 tree result; 10491 10492 #define WALK_SUBTREE_TAIL(NODE) \ 10493 do \ 10494 { \ 10495 tp = & (NODE); \ 10496 goto tail_recurse; \ 10497 } \ 10498 while (0) 10499 10500 tail_recurse: 10501 /* Skip empty subtrees. */ 10502 if (!*tp) 10503 return NULL_TREE; 10504 10505 /* Don't walk the same tree twice, if the user has requested 10506 that we avoid doing so. */ 10507 if (pset && pointer_set_insert (pset, *tp)) 10508 return NULL_TREE; 10509 10510 /* Call the function. */ 10511 walk_subtrees = 1; 10512 result = (*func) (tp, &walk_subtrees, data); 10513 10514 /* If we found something, return it. */ 10515 if (result) 10516 return result; 10517 10518 code = TREE_CODE (*tp); 10519 10520 /* Even if we didn't, FUNC may have decided that there was nothing 10521 interesting below this point in the tree. */ 10522 if (!walk_subtrees) 10523 { 10524 /* But we still need to check our siblings. */ 10525 if (code == TREE_LIST) 10526 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp)); 10527 else if (code == OMP_CLAUSE) 10528 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 10529 else 10530 return NULL_TREE; 10531 } 10532 10533 if (lh) 10534 { 10535 result = (*lh) (tp, &walk_subtrees, func, data, pset); 10536 if (result || !walk_subtrees) 10537 return result; 10538 } 10539 10540 switch (code) 10541 { 10542 case ERROR_MARK: 10543 case IDENTIFIER_NODE: 10544 case INTEGER_CST: 10545 case REAL_CST: 10546 case FIXED_CST: 10547 case VECTOR_CST: 10548 case STRING_CST: 10549 case BLOCK: 10550 case PLACEHOLDER_EXPR: 10551 case SSA_NAME: 10552 case FIELD_DECL: 10553 case RESULT_DECL: 10554 /* None of these have subtrees other than those already walked 10555 above. */ 10556 break; 10557 10558 case TREE_LIST: 10559 WALK_SUBTREE (TREE_VALUE (*tp)); 10560 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp)); 10561 break; 10562 10563 case TREE_VEC: 10564 { 10565 int len = TREE_VEC_LENGTH (*tp); 10566 10567 if (len == 0) 10568 break; 10569 10570 /* Walk all elements but the first. */ 10571 while (--len) 10572 WALK_SUBTREE (TREE_VEC_ELT (*tp, len)); 10573 10574 /* Now walk the first one as a tail call. */ 10575 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0)); 10576 } 10577 10578 case COMPLEX_CST: 10579 WALK_SUBTREE (TREE_REALPART (*tp)); 10580 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp)); 10581 10582 case CONSTRUCTOR: 10583 { 10584 unsigned HOST_WIDE_INT idx; 10585 constructor_elt *ce; 10586 10587 for (idx = 0; 10588 VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce); 10589 idx++) 10590 WALK_SUBTREE (ce->value); 10591 } 10592 break; 10593 10594 case SAVE_EXPR: 10595 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0)); 10596 10597 case BIND_EXPR: 10598 { 10599 tree decl; 10600 for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl)) 10601 { 10602 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk 10603 into declarations that are just mentioned, rather than 10604 declared; they don't really belong to this part of the tree. 10605 And, we can see cycles: the initializer for a declaration 10606 can refer to the declaration itself. */ 10607 WALK_SUBTREE (DECL_INITIAL (decl)); 10608 WALK_SUBTREE (DECL_SIZE (decl)); 10609 WALK_SUBTREE (DECL_SIZE_UNIT (decl)); 10610 } 10611 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp)); 10612 } 10613 10614 case STATEMENT_LIST: 10615 { 10616 tree_stmt_iterator i; 10617 for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i)) 10618 WALK_SUBTREE (*tsi_stmt_ptr (i)); 10619 } 10620 break; 10621 10622 case OMP_CLAUSE: 10623 switch (OMP_CLAUSE_CODE (*tp)) 10624 { 10625 case OMP_CLAUSE_PRIVATE: 10626 case OMP_CLAUSE_SHARED: 10627 case OMP_CLAUSE_FIRSTPRIVATE: 10628 case OMP_CLAUSE_COPYIN: 10629 case OMP_CLAUSE_COPYPRIVATE: 10630 case OMP_CLAUSE_FINAL: 10631 case OMP_CLAUSE_IF: 10632 case OMP_CLAUSE_NUM_THREADS: 10633 case OMP_CLAUSE_SCHEDULE: 10634 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0)); 10635 /* FALLTHRU */ 10636 10637 case OMP_CLAUSE_NOWAIT: 10638 case OMP_CLAUSE_ORDERED: 10639 case OMP_CLAUSE_DEFAULT: 10640 case OMP_CLAUSE_UNTIED: 10641 case OMP_CLAUSE_MERGEABLE: 10642 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 10643 10644 case OMP_CLAUSE_LASTPRIVATE: 10645 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp)); 10646 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp)); 10647 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 10648 10649 case OMP_CLAUSE_COLLAPSE: 10650 { 10651 int i; 10652 for (i = 0; i < 3; i++) 10653 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i)); 10654 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 10655 } 10656 10657 case OMP_CLAUSE_REDUCTION: 10658 { 10659 int i; 10660 for (i = 0; i < 4; i++) 10661 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i)); 10662 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 10663 } 10664 10665 default: 10666 gcc_unreachable (); 10667 } 10668 break; 10669 10670 case TARGET_EXPR: 10671 { 10672 int i, len; 10673 10674 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same. 10675 But, we only want to walk once. */ 10676 len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3; 10677 for (i = 0; i < len; ++i) 10678 WALK_SUBTREE (TREE_OPERAND (*tp, i)); 10679 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len)); 10680 } 10681 10682 case DECL_EXPR: 10683 /* If this is a TYPE_DECL, walk into the fields of the type that it's 10684 defining. We only want to walk into these fields of a type in this 10685 case and not in the general case of a mere reference to the type. 10686 10687 The criterion is as follows: if the field can be an expression, it 10688 must be walked only here. This should be in keeping with the fields 10689 that are directly gimplified in gimplify_type_sizes in order for the 10690 mark/copy-if-shared/unmark machinery of the gimplifier to work with 10691 variable-sized types. 10692 10693 Note that DECLs get walked as part of processing the BIND_EXPR. */ 10694 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL) 10695 { 10696 tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp)); 10697 if (TREE_CODE (*type_p) == ERROR_MARK) 10698 return NULL_TREE; 10699 10700 /* Call the function for the type. See if it returns anything or 10701 doesn't want us to continue. If we are to continue, walk both 10702 the normal fields and those for the declaration case. */ 10703 result = (*func) (type_p, &walk_subtrees, data); 10704 if (result || !walk_subtrees) 10705 return result; 10706 10707 /* But do not walk a pointed-to type since it may itself need to 10708 be walked in the declaration case if it isn't anonymous. */ 10709 if (!POINTER_TYPE_P (*type_p)) 10710 { 10711 result = walk_type_fields (*type_p, func, data, pset, lh); 10712 if (result) 10713 return result; 10714 } 10715 10716 /* If this is a record type, also walk the fields. */ 10717 if (RECORD_OR_UNION_TYPE_P (*type_p)) 10718 { 10719 tree field; 10720 10721 for (field = TYPE_FIELDS (*type_p); field; 10722 field = DECL_CHAIN (field)) 10723 { 10724 /* We'd like to look at the type of the field, but we can 10725 easily get infinite recursion. So assume it's pointed 10726 to elsewhere in the tree. Also, ignore things that 10727 aren't fields. */ 10728 if (TREE_CODE (field) != FIELD_DECL) 10729 continue; 10730 10731 WALK_SUBTREE (DECL_FIELD_OFFSET (field)); 10732 WALK_SUBTREE (DECL_SIZE (field)); 10733 WALK_SUBTREE (DECL_SIZE_UNIT (field)); 10734 if (TREE_CODE (*type_p) == QUAL_UNION_TYPE) 10735 WALK_SUBTREE (DECL_QUALIFIER (field)); 10736 } 10737 } 10738 10739 /* Same for scalar types. */ 10740 else if (TREE_CODE (*type_p) == BOOLEAN_TYPE 10741 || TREE_CODE (*type_p) == ENUMERAL_TYPE 10742 || TREE_CODE (*type_p) == INTEGER_TYPE 10743 || TREE_CODE (*type_p) == FIXED_POINT_TYPE 10744 || TREE_CODE (*type_p) == REAL_TYPE) 10745 { 10746 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p)); 10747 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p)); 10748 } 10749 10750 WALK_SUBTREE (TYPE_SIZE (*type_p)); 10751 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p)); 10752 } 10753 /* FALLTHRU */ 10754 10755 default: 10756 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))) 10757 { 10758 int i, len; 10759 10760 /* Walk over all the sub-trees of this operand. */ 10761 len = TREE_OPERAND_LENGTH (*tp); 10762 10763 /* Go through the subtrees. We need to do this in forward order so 10764 that the scope of a FOR_EXPR is handled properly. */ 10765 if (len) 10766 { 10767 for (i = 0; i < len - 1; ++i) 10768 WALK_SUBTREE (TREE_OPERAND (*tp, i)); 10769 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1)); 10770 } 10771 } 10772 /* If this is a type, walk the needed fields in the type. */ 10773 else if (TYPE_P (*tp)) 10774 return walk_type_fields (*tp, func, data, pset, lh); 10775 break; 10776 } 10777 10778 /* We didn't find what we were looking for. */ 10779 return NULL_TREE; 10780 10781 #undef WALK_SUBTREE_TAIL 10782 } 10783 #undef WALK_SUBTREE 10784 10785 /* Like walk_tree, but does not walk duplicate nodes more than once. */ 10786 10787 tree 10788 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data, 10789 walk_tree_lh lh) 10790 { 10791 tree result; 10792 struct pointer_set_t *pset; 10793 10794 pset = pointer_set_create (); 10795 result = walk_tree_1 (tp, func, data, pset, lh); 10796 pointer_set_destroy (pset); 10797 return result; 10798 } 10799 10800 10801 tree * 10802 tree_block (tree t) 10803 { 10804 char const c = TREE_CODE_CLASS (TREE_CODE (t)); 10805 10806 if (IS_EXPR_CODE_CLASS (c)) 10807 return &t->exp.block; 10808 gcc_unreachable (); 10809 return NULL; 10810 } 10811 10812 /* Create a nameless artificial label and put it in the current 10813 function context. The label has a location of LOC. Returns the 10814 newly created label. */ 10815 10816 tree 10817 create_artificial_label (location_t loc) 10818 { 10819 tree lab = build_decl (loc, 10820 LABEL_DECL, NULL_TREE, void_type_node); 10821 10822 DECL_ARTIFICIAL (lab) = 1; 10823 DECL_IGNORED_P (lab) = 1; 10824 DECL_CONTEXT (lab) = current_function_decl; 10825 return lab; 10826 } 10827 10828 /* Given a tree, try to return a useful variable name that we can use 10829 to prefix a temporary that is being assigned the value of the tree. 10830 I.E. given <temp> = &A, return A. */ 10831 10832 const char * 10833 get_name (tree t) 10834 { 10835 tree stripped_decl; 10836 10837 stripped_decl = t; 10838 STRIP_NOPS (stripped_decl); 10839 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl)) 10840 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl)); 10841 else 10842 { 10843 switch (TREE_CODE (stripped_decl)) 10844 { 10845 case ADDR_EXPR: 10846 return get_name (TREE_OPERAND (stripped_decl, 0)); 10847 default: 10848 return NULL; 10849 } 10850 } 10851 } 10852 10853 /* Return true if TYPE has a variable argument list. */ 10854 10855 bool 10856 stdarg_p (const_tree fntype) 10857 { 10858 function_args_iterator args_iter; 10859 tree n = NULL_TREE, t; 10860 10861 if (!fntype) 10862 return false; 10863 10864 FOREACH_FUNCTION_ARGS(fntype, t, args_iter) 10865 { 10866 n = t; 10867 } 10868 10869 return n != NULL_TREE && n != void_type_node; 10870 } 10871 10872 /* Return true if TYPE has a prototype. */ 10873 10874 bool 10875 prototype_p (tree fntype) 10876 { 10877 tree t; 10878 10879 gcc_assert (fntype != NULL_TREE); 10880 10881 t = TYPE_ARG_TYPES (fntype); 10882 return (t != NULL_TREE); 10883 } 10884 10885 /* If BLOCK is inlined from an __attribute__((__artificial__)) 10886 routine, return pointer to location from where it has been 10887 called. */ 10888 location_t * 10889 block_nonartificial_location (tree block) 10890 { 10891 location_t *ret = NULL; 10892 10893 while (block && TREE_CODE (block) == BLOCK 10894 && BLOCK_ABSTRACT_ORIGIN (block)) 10895 { 10896 tree ao = BLOCK_ABSTRACT_ORIGIN (block); 10897 10898 while (TREE_CODE (ao) == BLOCK 10899 && BLOCK_ABSTRACT_ORIGIN (ao) 10900 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 10901 ao = BLOCK_ABSTRACT_ORIGIN (ao); 10902 10903 if (TREE_CODE (ao) == FUNCTION_DECL) 10904 { 10905 /* If AO is an artificial inline, point RET to the 10906 call site locus at which it has been inlined and continue 10907 the loop, in case AO's caller is also an artificial 10908 inline. */ 10909 if (DECL_DECLARED_INLINE_P (ao) 10910 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao))) 10911 ret = &BLOCK_SOURCE_LOCATION (block); 10912 else 10913 break; 10914 } 10915 else if (TREE_CODE (ao) != BLOCK) 10916 break; 10917 10918 block = BLOCK_SUPERCONTEXT (block); 10919 } 10920 return ret; 10921 } 10922 10923 10924 /* If EXP is inlined from an __attribute__((__artificial__)) 10925 function, return the location of the original call expression. */ 10926 10927 location_t 10928 tree_nonartificial_location (tree exp) 10929 { 10930 location_t *loc = block_nonartificial_location (TREE_BLOCK (exp)); 10931 10932 if (loc) 10933 return *loc; 10934 else 10935 return EXPR_LOCATION (exp); 10936 } 10937 10938 10939 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq 10940 nodes. */ 10941 10942 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */ 10943 10944 static hashval_t 10945 cl_option_hash_hash (const void *x) 10946 { 10947 const_tree const t = (const_tree) x; 10948 const char *p; 10949 size_t i; 10950 size_t len = 0; 10951 hashval_t hash = 0; 10952 10953 if (TREE_CODE (t) == OPTIMIZATION_NODE) 10954 { 10955 p = (const char *)TREE_OPTIMIZATION (t); 10956 len = sizeof (struct cl_optimization); 10957 } 10958 10959 else if (TREE_CODE (t) == TARGET_OPTION_NODE) 10960 { 10961 p = (const char *)TREE_TARGET_OPTION (t); 10962 len = sizeof (struct cl_target_option); 10963 } 10964 10965 else 10966 gcc_unreachable (); 10967 10968 /* assume most opt flags are just 0/1, some are 2-3, and a few might be 10969 something else. */ 10970 for (i = 0; i < len; i++) 10971 if (p[i]) 10972 hash = (hash << 4) ^ ((i << 2) | p[i]); 10973 10974 return hash; 10975 } 10976 10977 /* Return nonzero if the value represented by *X (an OPTIMIZATION or 10978 TARGET_OPTION tree node) is the same as that given by *Y, which is the 10979 same. */ 10980 10981 static int 10982 cl_option_hash_eq (const void *x, const void *y) 10983 { 10984 const_tree const xt = (const_tree) x; 10985 const_tree const yt = (const_tree) y; 10986 const char *xp; 10987 const char *yp; 10988 size_t len; 10989 10990 if (TREE_CODE (xt) != TREE_CODE (yt)) 10991 return 0; 10992 10993 if (TREE_CODE (xt) == OPTIMIZATION_NODE) 10994 { 10995 xp = (const char *)TREE_OPTIMIZATION (xt); 10996 yp = (const char *)TREE_OPTIMIZATION (yt); 10997 len = sizeof (struct cl_optimization); 10998 } 10999 11000 else if (TREE_CODE (xt) == TARGET_OPTION_NODE) 11001 { 11002 xp = (const char *)TREE_TARGET_OPTION (xt); 11003 yp = (const char *)TREE_TARGET_OPTION (yt); 11004 len = sizeof (struct cl_target_option); 11005 } 11006 11007 else 11008 gcc_unreachable (); 11009 11010 return (memcmp (xp, yp, len) == 0); 11011 } 11012 11013 /* Build an OPTIMIZATION_NODE based on the current options. */ 11014 11015 tree 11016 build_optimization_node (void) 11017 { 11018 tree t; 11019 void **slot; 11020 11021 /* Use the cache of optimization nodes. */ 11022 11023 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node), 11024 &global_options); 11025 11026 slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT); 11027 t = (tree) *slot; 11028 if (!t) 11029 { 11030 /* Insert this one into the hash table. */ 11031 t = cl_optimization_node; 11032 *slot = t; 11033 11034 /* Make a new node for next time round. */ 11035 cl_optimization_node = make_node (OPTIMIZATION_NODE); 11036 } 11037 11038 return t; 11039 } 11040 11041 /* Build a TARGET_OPTION_NODE based on the current options. */ 11042 11043 tree 11044 build_target_option_node (void) 11045 { 11046 tree t; 11047 void **slot; 11048 11049 /* Use the cache of optimization nodes. */ 11050 11051 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node), 11052 &global_options); 11053 11054 slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT); 11055 t = (tree) *slot; 11056 if (!t) 11057 { 11058 /* Insert this one into the hash table. */ 11059 t = cl_target_option_node; 11060 *slot = t; 11061 11062 /* Make a new node for next time round. */ 11063 cl_target_option_node = make_node (TARGET_OPTION_NODE); 11064 } 11065 11066 return t; 11067 } 11068 11069 /* Determine the "ultimate origin" of a block. The block may be an inlined 11070 instance of an inlined instance of a block which is local to an inline 11071 function, so we have to trace all of the way back through the origin chain 11072 to find out what sort of node actually served as the original seed for the 11073 given block. */ 11074 11075 tree 11076 block_ultimate_origin (const_tree block) 11077 { 11078 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 11079 11080 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the 11081 nodes in the function to point to themselves; ignore that if 11082 we're trying to output the abstract instance of this function. */ 11083 if (BLOCK_ABSTRACT (block) && immediate_origin == block) 11084 return NULL_TREE; 11085 11086 if (immediate_origin == NULL_TREE) 11087 return NULL_TREE; 11088 else 11089 { 11090 tree ret_val; 11091 tree lookahead = immediate_origin; 11092 11093 do 11094 { 11095 ret_val = lookahead; 11096 lookahead = (TREE_CODE (ret_val) == BLOCK 11097 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL); 11098 } 11099 while (lookahead != NULL && lookahead != ret_val); 11100 11101 /* The block's abstract origin chain may not be the *ultimate* origin of 11102 the block. It could lead to a DECL that has an abstract origin set. 11103 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN 11104 will give us if it has one). Note that DECL's abstract origins are 11105 supposed to be the most distant ancestor (or so decl_ultimate_origin 11106 claims), so we don't need to loop following the DECL origins. */ 11107 if (DECL_P (ret_val)) 11108 return DECL_ORIGIN (ret_val); 11109 11110 return ret_val; 11111 } 11112 } 11113 11114 /* Return true if T1 and T2 are equivalent lists. */ 11115 11116 bool 11117 list_equal_p (const_tree t1, const_tree t2) 11118 { 11119 for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2)) 11120 if (TREE_VALUE (t1) != TREE_VALUE (t2)) 11121 return false; 11122 return !t1 && !t2; 11123 } 11124 11125 /* Return true iff conversion in EXP generates no instruction. Mark 11126 it inline so that we fully inline into the stripping functions even 11127 though we have two uses of this function. */ 11128 11129 static inline bool 11130 tree_nop_conversion (const_tree exp) 11131 { 11132 tree outer_type, inner_type; 11133 11134 if (!CONVERT_EXPR_P (exp) 11135 && TREE_CODE (exp) != NON_LVALUE_EXPR) 11136 return false; 11137 if (TREE_OPERAND (exp, 0) == error_mark_node) 11138 return false; 11139 11140 outer_type = TREE_TYPE (exp); 11141 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0)); 11142 11143 if (!inner_type) 11144 return false; 11145 11146 /* Use precision rather then machine mode when we can, which gives 11147 the correct answer even for submode (bit-field) types. */ 11148 if ((INTEGRAL_TYPE_P (outer_type) 11149 || POINTER_TYPE_P (outer_type) 11150 || TREE_CODE (outer_type) == OFFSET_TYPE) 11151 && (INTEGRAL_TYPE_P (inner_type) 11152 || POINTER_TYPE_P (inner_type) 11153 || TREE_CODE (inner_type) == OFFSET_TYPE)) 11154 return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type); 11155 11156 /* Otherwise fall back on comparing machine modes (e.g. for 11157 aggregate types, floats). */ 11158 return TYPE_MODE (outer_type) == TYPE_MODE (inner_type); 11159 } 11160 11161 /* Return true iff conversion in EXP generates no instruction. Don't 11162 consider conversions changing the signedness. */ 11163 11164 static bool 11165 tree_sign_nop_conversion (const_tree exp) 11166 { 11167 tree outer_type, inner_type; 11168 11169 if (!tree_nop_conversion (exp)) 11170 return false; 11171 11172 outer_type = TREE_TYPE (exp); 11173 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0)); 11174 11175 return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type) 11176 && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type)); 11177 } 11178 11179 /* Strip conversions from EXP according to tree_nop_conversion and 11180 return the resulting expression. */ 11181 11182 tree 11183 tree_strip_nop_conversions (tree exp) 11184 { 11185 while (tree_nop_conversion (exp)) 11186 exp = TREE_OPERAND (exp, 0); 11187 return exp; 11188 } 11189 11190 /* Strip conversions from EXP according to tree_sign_nop_conversion 11191 and return the resulting expression. */ 11192 11193 tree 11194 tree_strip_sign_nop_conversions (tree exp) 11195 { 11196 while (tree_sign_nop_conversion (exp)) 11197 exp = TREE_OPERAND (exp, 0); 11198 return exp; 11199 } 11200 11201 /* Strip out all handled components that produce invariant 11202 offsets. */ 11203 11204 const_tree 11205 strip_invariant_refs (const_tree op) 11206 { 11207 while (handled_component_p (op)) 11208 { 11209 switch (TREE_CODE (op)) 11210 { 11211 case ARRAY_REF: 11212 case ARRAY_RANGE_REF: 11213 if (!is_gimple_constant (TREE_OPERAND (op, 1)) 11214 || TREE_OPERAND (op, 2) != NULL_TREE 11215 || TREE_OPERAND (op, 3) != NULL_TREE) 11216 return NULL; 11217 break; 11218 11219 case COMPONENT_REF: 11220 if (TREE_OPERAND (op, 2) != NULL_TREE) 11221 return NULL; 11222 break; 11223 11224 default:; 11225 } 11226 op = TREE_OPERAND (op, 0); 11227 } 11228 11229 return op; 11230 } 11231 11232 static GTY(()) tree gcc_eh_personality_decl; 11233 11234 /* Return the GCC personality function decl. */ 11235 11236 tree 11237 lhd_gcc_personality (void) 11238 { 11239 if (!gcc_eh_personality_decl) 11240 gcc_eh_personality_decl = build_personality_function ("gcc"); 11241 return gcc_eh_personality_decl; 11242 } 11243 11244 /* Try to find a base info of BINFO that would have its field decl at offset 11245 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be 11246 found, return, otherwise return NULL_TREE. */ 11247 11248 tree 11249 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type) 11250 { 11251 tree type = BINFO_TYPE (binfo); 11252 11253 while (true) 11254 { 11255 HOST_WIDE_INT pos, size; 11256 tree fld; 11257 int i; 11258 11259 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (expected_type)) 11260 return binfo; 11261 if (offset < 0) 11262 return NULL_TREE; 11263 11264 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld)) 11265 { 11266 if (TREE_CODE (fld) != FIELD_DECL) 11267 continue; 11268 11269 pos = int_bit_position (fld); 11270 size = tree_low_cst (DECL_SIZE (fld), 1); 11271 if (pos <= offset && (pos + size) > offset) 11272 break; 11273 } 11274 if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE) 11275 return NULL_TREE; 11276 11277 if (!DECL_ARTIFICIAL (fld)) 11278 { 11279 binfo = TYPE_BINFO (TREE_TYPE (fld)); 11280 if (!binfo) 11281 return NULL_TREE; 11282 } 11283 /* Offset 0 indicates the primary base, whose vtable contents are 11284 represented in the binfo for the derived class. */ 11285 else if (offset != 0) 11286 { 11287 tree base_binfo, found_binfo = NULL_TREE; 11288 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 11289 if (TREE_TYPE (base_binfo) == TREE_TYPE (fld)) 11290 { 11291 found_binfo = base_binfo; 11292 break; 11293 } 11294 if (!found_binfo) 11295 return NULL_TREE; 11296 binfo = found_binfo; 11297 } 11298 11299 type = TREE_TYPE (fld); 11300 offset -= pos; 11301 } 11302 } 11303 11304 /* Returns true if X is a typedef decl. */ 11305 11306 bool 11307 is_typedef_decl (tree x) 11308 { 11309 return (x && TREE_CODE (x) == TYPE_DECL 11310 && DECL_ORIGINAL_TYPE (x) != NULL_TREE); 11311 } 11312 11313 /* Returns true iff TYPE is a type variant created for a typedef. */ 11314 11315 bool 11316 typedef_variant_p (tree type) 11317 { 11318 return is_typedef_decl (TYPE_NAME (type)); 11319 } 11320 11321 /* Warn about a use of an identifier which was marked deprecated. */ 11322 void 11323 warn_deprecated_use (tree node, tree attr) 11324 { 11325 const char *msg; 11326 11327 if (node == 0 || !warn_deprecated_decl) 11328 return; 11329 11330 if (!attr) 11331 { 11332 if (DECL_P (node)) 11333 attr = DECL_ATTRIBUTES (node); 11334 else if (TYPE_P (node)) 11335 { 11336 tree decl = TYPE_STUB_DECL (node); 11337 if (decl) 11338 attr = lookup_attribute ("deprecated", 11339 TYPE_ATTRIBUTES (TREE_TYPE (decl))); 11340 } 11341 } 11342 11343 if (attr) 11344 attr = lookup_attribute ("deprecated", attr); 11345 11346 if (attr) 11347 msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))); 11348 else 11349 msg = NULL; 11350 11351 if (DECL_P (node)) 11352 { 11353 expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node)); 11354 if (msg) 11355 warning (OPT_Wdeprecated_declarations, 11356 "%qD is deprecated (declared at %s:%d): %s", 11357 node, xloc.file, xloc.line, msg); 11358 else 11359 warning (OPT_Wdeprecated_declarations, 11360 "%qD is deprecated (declared at %s:%d)", 11361 node, xloc.file, xloc.line); 11362 } 11363 else if (TYPE_P (node)) 11364 { 11365 tree what = NULL_TREE; 11366 tree decl = TYPE_STUB_DECL (node); 11367 11368 if (TYPE_NAME (node)) 11369 { 11370 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) 11371 what = TYPE_NAME (node); 11372 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL 11373 && DECL_NAME (TYPE_NAME (node))) 11374 what = DECL_NAME (TYPE_NAME (node)); 11375 } 11376 11377 if (decl) 11378 { 11379 expanded_location xloc 11380 = expand_location (DECL_SOURCE_LOCATION (decl)); 11381 if (what) 11382 { 11383 if (msg) 11384 warning (OPT_Wdeprecated_declarations, 11385 "%qE is deprecated (declared at %s:%d): %s", 11386 what, xloc.file, xloc.line, msg); 11387 else 11388 warning (OPT_Wdeprecated_declarations, 11389 "%qE is deprecated (declared at %s:%d)", what, 11390 xloc.file, xloc.line); 11391 } 11392 else 11393 { 11394 if (msg) 11395 warning (OPT_Wdeprecated_declarations, 11396 "type is deprecated (declared at %s:%d): %s", 11397 xloc.file, xloc.line, msg); 11398 else 11399 warning (OPT_Wdeprecated_declarations, 11400 "type is deprecated (declared at %s:%d)", 11401 xloc.file, xloc.line); 11402 } 11403 } 11404 else 11405 { 11406 if (what) 11407 { 11408 if (msg) 11409 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s", 11410 what, msg); 11411 else 11412 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what); 11413 } 11414 else 11415 { 11416 if (msg) 11417 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s", 11418 msg); 11419 else 11420 warning (OPT_Wdeprecated_declarations, "type is deprecated"); 11421 } 11422 } 11423 } 11424 } 11425 11426 #include "gt-tree.h" 11427