gcc/tree.c

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