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