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 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  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    The low-level allocation routines oballoc and permalloc
  33    are used also for allocating many other kinds of objects
  34    by all passes of the compiler.  */
  35
  36 #include "config.h"
  37 #include "system.h"
  38 #include "flags.h"
  39 #include "tree.h"
  40 #include "tm_p.h"
  41 #include "function.h"
  42 #include "obstack.h"
  43 #include "toplev.h"
  44 #include "ggc.h"
  45 #include "hashtab.h"
  46 #include "output.h"
  47 #include "target.h"
  48
  49 #define obstack_chunk_alloc xmalloc
  50 #define obstack_chunk_free free
  51 /* obstack.[ch] explicitly declined to prototype this.  */
  52 extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj));
  53
  54 static void unsave_expr_now_r PARAMS ((tree));
  55
  56 /* Objects allocated on this obstack last forever.  */
  57
  58 struct obstack permanent_obstack;
  59
  60 /* Table indexed by tree code giving a string containing a character
  61    classifying the tree code.  Possibilities are
  62    t, d, s, c, r, <, 1, 2 and e.  See tree.def for details.  */
  63
  64 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  65
  66 char tree_code_type[MAX_TREE_CODES] = {
  67 #include "tree.def"
  68 };
  69 #undef DEFTREECODE
  70
  71 /* Table indexed by tree code giving number of expression
  72    operands beyond the fixed part of the node structure.
  73    Not used for types or decls.  */
  74
  75 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  76
  77 int tree_code_length[MAX_TREE_CODES] = {
  78 #include "tree.def"
  79 };
  80 #undef DEFTREECODE
  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
  86 const char *tree_code_name[MAX_TREE_CODES] = {
  87 #include "tree.def"
  88 };
  89 #undef DEFTREECODE
  90
  91 /* Statistics-gathering stuff.  */
  92 typedef enum
  93 {
  94   d_kind,
  95   t_kind,
  96   b_kind,
  97   s_kind,
  98   r_kind,
  99   e_kind,
 100   c_kind,
 101   id_kind,
 102   perm_list_kind,
 103   temp_list_kind,
 104   vec_kind,
 105   x_kind,
 106   lang_decl,
 107   lang_type,
 108   all_kinds
 109 } tree_node_kind;
 110
 111 int tree_node_counts[(int) all_kinds];
 112 int tree_node_sizes[(int) all_kinds];
 113 int id_string_size = 0;
 114
 115 static const char * const tree_node_kind_names[] = {
 116   "decls",
 117   "types",
 118   "blocks",
 119   "stmts",
 120   "refs",
 121   "exprs",
 122   "constants",
 123   "identifiers",
 124   "perm_tree_lists",
 125   "temp_tree_lists",
 126   "vecs",
 127   "random kinds",
 128   "lang_decl kinds",
 129   "lang_type kinds"
 130 };
 131
 132 /* Unique id for next decl created.  */
 133 static int next_decl_uid;
 134 /* Unique id for next type created.  */
 135 static int next_type_uid = 1;
 136
 137 /* Since we cannot rehash a type after it is in the table, we have to
 138    keep the hash code.  */
 139
 140 struct type_hash
 141 {
 142   unsigned long hash;
 143   tree type;
 144 };
 145
 146 /* Initial size of the hash table (rounded to next prime).  */
 147 #define TYPE_HASH_INITIAL_SIZE 1000
 148
 149 /* Now here is the hash table.  When recording a type, it is added to
 150    the slot whose index is the hash code.  Note that the hash table is
 151    used for several kinds of types (function types, array types and
 152    array index range types, for now).  While all these live in the
 153    same table, they are completely independent, and the hash code is
 154    computed differently for each of these.  */
 155
 156 htab_t type_hash_table;
 157
 158 static void build_real_from_int_cst_1 PARAMS ((PTR));
 159 static void set_type_quals PARAMS ((tree, int));
 160 static void append_random_chars PARAMS ((char *));
 161 static int type_hash_eq PARAMS ((const void*, const void*));
 162 static unsigned int type_hash_hash PARAMS ((const void*));
 163 static void print_type_hash_statistics PARAMS((void));
 164 static void finish_vector_type PARAMS((tree));
 165 static int type_hash_marked_p PARAMS ((const void *));
 166 static void type_hash_mark PARAMS ((const void *));
 167 static int mark_tree_hashtable_entry PARAMS((void **, void *));
 168
 169 /* If non-null, these are language-specific helper functions for
 170    unsave_expr_now.  If present, LANG_UNSAVE is called before its
 171    argument (an UNSAVE_EXPR) is to be unsaved, and all other
 172    processing in unsave_expr_now is aborted.  LANG_UNSAVE_EXPR_NOW is
 173    called from unsave_expr_1 for language-specific tree codes.  */
 174 void (*lang_unsave) PARAMS ((tree *));
 175 void (*lang_unsave_expr_now) PARAMS ((tree));
 176
 177 /* If non-null, these are language-specific helper functions for
 178    unsafe_for_reeval.  Return negative to not handle some tree.  */
 179 int (*lang_unsafe_for_reeval) PARAMS ((tree));
 180
 181 /* Set the DECL_ASSEMBLER_NAME for a node.  If it is the sort of thing
 182    that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
 183    appropriate IDENTIFIER_NODE.  Otherwise, set it to the
 184    ERROR_MARK_NODE to ensure that the assembler does not talk about
 185    it.  */
 186 void (*lang_set_decl_assembler_name)     PARAMS ((tree));
 187 \f
 188 tree global_trees[TI_MAX];
 189 tree integer_types[itk_none];
 190 \f
 191 /* Set the DECL_ASSEMBLER_NAME for DECL.  */
 192 void
 193 set_decl_assembler_name (decl)
 194      tree decl;
 195 {
 196   /* The language-independent code should never use the
 197      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
 198      VAR_DECLs for variables with static storage duration need a real
 199      DECL_ASSEMBLER_NAME.  */
 200   if (TREE_CODE (decl) == FUNCTION_DECL
 201       || (TREE_CODE (decl) == VAR_DECL
 202           && (TREE_STATIC (decl)
 203               || DECL_EXTERNAL (decl)
 204               || TREE_PUBLIC (decl))))
 205     /* By default, assume the name to use in assembly code is the
 206        same as that used in the source language.  (That's correct
 207        for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
 208        value as DECL_NAME in build_decl, so this choice provides
 209        backwards compatibility with existing front-ends.  */
 210     SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
 211   else
 212     /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
 213        these DECLs -- unless they're in language-dependent code, in
 214        which case lang_set_decl_assembler_name should handle things.  */
 215     abort ();
 216 }
 217 \f
 218 /* Init the principal obstacks.  */
 219
 220 void
 221 init_obstacks ()
 222 {
 223   gcc_obstack_init (&permanent_obstack);
 224
 225   /* Initialize the hash table of types.  */
 226   type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
 227                                  type_hash_eq, 0);
 228   ggc_add_deletable_htab (type_hash_table, type_hash_marked_p,
 229                           type_hash_mark);
 230   ggc_add_tree_root (global_trees, TI_MAX);
 231   ggc_add_tree_root (integer_types, itk_none);
 232
 233   /* Set lang_set_decl_set_assembler_name to a default value.  */
 234   lang_set_decl_assembler_name = set_decl_assembler_name;
 235 }
 236
 237 \f
 238 /* Allocate SIZE bytes in the permanent obstack
 239    and return a pointer to them.  */
 240
 241 char *
 242 permalloc (size)
 243      int size;
 244 {
 245   return (char *) obstack_alloc (&permanent_obstack, size);
 246 }
 247
 248 /* Allocate NELEM items of SIZE bytes in the permanent obstack
 249    and return a pointer to them.  The storage is cleared before
 250    returning the value.  */
 251
 252 char *
 253 perm_calloc (nelem, size)
 254      int nelem;
 255      long size;
 256 {
 257   char *rval = (char *) obstack_alloc (&permanent_obstack, nelem * size);
 258   memset (rval, 0, nelem * size);
 259   return rval;
 260 }
 261
 262 /* Compute the number of bytes occupied by 'node'.  This routine only
 263    looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH.  */
 264 size_t
 265 tree_size (node)
 266      tree node;
 267 {
 268   enum tree_code code = TREE_CODE (node);
 269
 270   switch (TREE_CODE_CLASS (code))
 271     {
 272     case 'd':  /* A decl node */
 273       return sizeof (struct tree_decl);
 274
 275     case 't':  /* a type node */
 276       return sizeof (struct tree_type);
 277
 278     case 'b':  /* a lexical block node */
 279       return sizeof (struct tree_block);
 280
 281     case 'r':  /* a reference */
 282     case 'e':  /* an expression */
 283     case 's':  /* an expression with side effects */
 284     case '<':  /* a comparison expression */
 285     case '1':  /* a unary arithmetic expression */
 286     case '2':  /* a binary arithmetic expression */
 287       return (sizeof (struct tree_exp)
 288               + (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
 289
 290     case 'c':  /* a constant */
 291       /* We can't use TREE_CODE_LENGTH for INTEGER_CST, since the number of
 292          words is machine-dependent due to varying length of HOST_WIDE_INT,
 293          which might be wider than a pointer (e.g., long long).  Similarly
 294          for REAL_CST, since the number of words is machine-dependent due
 295          to varying size and alignment of `double'.  */
 296       if (code == INTEGER_CST)
 297         return sizeof (struct tree_int_cst);
 298       else if (code == REAL_CST)
 299         return sizeof (struct tree_real_cst);
 300       else
 301         return (sizeof (struct tree_common)
 302                 + TREE_CODE_LENGTH (code) * sizeof (char *));
 303
 304     case 'x':  /* something random, like an identifier.  */
 305       {
 306           size_t length;
 307           length = (sizeof (struct tree_common)
 308                     + TREE_CODE_LENGTH (code) * sizeof (char *));
 309           if (code == TREE_VEC)
 310             length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
 311           return length;
 312       }
 313
 314     default:
 315       abort ();
 316     }
 317 }
 318
 319 /* Return a newly allocated node of code CODE.
 320    For decl and type nodes, some other fields are initialized.
 321    The rest of the node is initialized to zero.
 322
 323    Achoo!  I got a code in the node.  */
 324
 325 tree
 326 make_node (code)
 327      enum tree_code code;
 328 {
 329   register tree t;
 330   register int type = TREE_CODE_CLASS (code);
 331   register size_t length;
 332 #ifdef GATHER_STATISTICS
 333   register tree_node_kind kind;
 334 #endif
 335   struct tree_common ttmp;
 336
 337   /* We can't allocate a TREE_VEC without knowing how many elements
 338      it will have.  */
 339   if (code == TREE_VEC)
 340     abort ();
 341
 342   TREE_SET_CODE ((tree)&ttmp, code);
 343   length = tree_size ((tree)&ttmp);
 344
 345 #ifdef GATHER_STATISTICS
 346   switch (type)
 347     {
 348     case 'd':  /* A decl node */
 349       kind = d_kind;
 350       break;
 351
 352     case 't':  /* a type node */
 353       kind = t_kind;
 354       break;
 355
 356     case 'b':  /* a lexical block */
 357       kind = b_kind;
 358       break;
 359
 360     case 's':  /* an expression with side effects */
 361       kind = s_kind;
 362       break;
 363
 364     case 'r':  /* a reference */
 365       kind = r_kind;
 366       break;
 367
 368     case 'e':  /* an expression */
 369     case '<':  /* a comparison expression */
 370     case '1':  /* a unary arithmetic expression */
 371     case '2':  /* a binary arithmetic expression */
 372       kind = e_kind;
 373       break;
 374
 375     case 'c':  /* a constant */
 376       kind = c_kind;
 377       break;
 378
 379     case 'x':  /* something random, like an identifier.  */
 380       if (code == IDENTIFIER_NODE)
 381         kind = id_kind;
 382       else if (code == TREE_VEC)
 383         kind = vec_kind;
 384       else
 385         kind = x_kind;
 386       break;
 387
 388     default:
 389       abort ();
 390     }
 391
 392   tree_node_counts[(int) kind]++;
 393   tree_node_sizes[(int) kind] += length;
 394 #endif
 395
 396   t = ggc_alloc_tree (length);
 397
 398   memset ((PTR) t, 0, length);
 399
 400   TREE_SET_CODE (t, code);
 401
 402   switch (type)
 403     {
 404     case 's':
 405       TREE_SIDE_EFFECTS (t) = 1;
 406       TREE_TYPE (t) = void_type_node;
 407       break;
 408
 409     case 'd':
 410       if (code != FUNCTION_DECL)
 411         DECL_ALIGN (t) = 1;
 412       DECL_USER_ALIGN (t) = 0;
 413       DECL_IN_SYSTEM_HEADER (t) = in_system_header;
 414       DECL_SOURCE_LINE (t) = lineno;
 415       DECL_SOURCE_FILE (t) =
 416         (input_filename) ? input_filename : "<built-in>";
 417       DECL_UID (t) = next_decl_uid++;
 418
 419       /* We have not yet computed the alias set for this declaration.  */
 420       DECL_POINTER_ALIAS_SET (t) = -1;
 421       break;
 422
 423     case 't':
 424       TYPE_UID (t) = next_type_uid++;
 425       TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
 426       TYPE_USER_ALIGN (t) = 0;
 427       TYPE_MAIN_VARIANT (t) = t;
 428
 429       /* Default to no attributes for type, but let target change that.  */
 430       TYPE_ATTRIBUTES (t) = NULL_TREE;
 431       (*targetm.set_default_type_attributes) (t);
 432
 433       /* We have not yet computed the alias set for this type.  */
 434       TYPE_ALIAS_SET (t) = -1;
 435       break;
 436
 437     case 'c':
 438       TREE_CONSTANT (t) = 1;
 439       break;
 440
 441     case 'e':
 442       switch (code)
 443         {
 444         case INIT_EXPR:
 445         case MODIFY_EXPR:
 446         case VA_ARG_EXPR:
 447         case RTL_EXPR:
 448         case PREDECREMENT_EXPR:
 449         case PREINCREMENT_EXPR:
 450         case POSTDECREMENT_EXPR:
 451         case POSTINCREMENT_EXPR:
 452           /* All of these have side-effects, no matter what their
 453              operands are.  */
 454           TREE_SIDE_EFFECTS (t) = 1;
 455           break;
 456
 457         default:
 458           break;
 459         }
 460       break;
 461     }
 462
 463   return t;
 464 }
 465
 466 /* A front-end can reset this to an appropriate function if types need
 467    special handling.  */
 468
 469 tree (*make_lang_type_fn) PARAMS ((enum tree_code)) = make_node;
 470
 471 /* Return a new type (with the indicated CODE), doing whatever
 472    language-specific processing is required.  */
 473
 474 tree
 475 make_lang_type (code)
 476      enum tree_code code;
 477 {
 478   return (*make_lang_type_fn) (code);
 479 }
 480 \f
 481 /* Return a new node with the same contents as NODE except that its
 482    TREE_CHAIN is zero and it has a fresh uid.  */
 483
 484 tree
 485 copy_node (node)
 486      tree node;
 487 {
 488   register tree t;
 489   register enum tree_code code = TREE_CODE (node);
 490   register size_t length;
 491
 492   length = tree_size (node);
 493   t = ggc_alloc_tree (length);
 494   memcpy (t, node, length);
 495
 496   TREE_CHAIN (t) = 0;
 497   TREE_ASM_WRITTEN (t) = 0;
 498
 499   if (TREE_CODE_CLASS (code) == 'd')
 500     DECL_UID (t) = next_decl_uid++;
 501   else if (TREE_CODE_CLASS (code) == 't')
 502     {
 503       TYPE_UID (t) = next_type_uid++;
 504       /* The following is so that the debug code for
 505          the copy is different from the original type.
 506          The two statements usually duplicate each other
 507          (because they clear fields of the same union),
 508          but the optimizer should catch that.  */
 509       TYPE_SYMTAB_POINTER (t) = 0;
 510       TYPE_SYMTAB_ADDRESS (t) = 0;
 511     }
 512
 513   return t;
 514 }
 515
 516 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
 517    For example, this can copy a list made of TREE_LIST nodes.  */
 518
 519 tree
 520 copy_list (list)
 521      tree list;
 522 {
 523   tree head;
 524   register tree prev, next;
 525
 526   if (list == 0)
 527     return 0;
 528
 529   head = prev = copy_node (list);
 530   next = TREE_CHAIN (list);
 531   while (next)
 532     {
 533       TREE_CHAIN (prev) = copy_node (next);
 534       prev = TREE_CHAIN (prev);
 535       next = TREE_CHAIN (next);
 536     }
 537   return head;
 538 }
 539
 540 \f
 541 /* Return a newly constructed INTEGER_CST node whose constant value
 542    is specified by the two ints LOW and HI.
 543    The TREE_TYPE is set to `int'.
 544
 545    This function should be used via the `build_int_2' macro.  */
 546
 547 tree
 548 build_int_2_wide (low, hi)
 549      unsigned HOST_WIDE_INT low;
 550      HOST_WIDE_INT hi;
 551 {
 552   register tree t = make_node (INTEGER_CST);
 553
 554   TREE_INT_CST_LOW (t) = low;
 555   TREE_INT_CST_HIGH (t) = hi;
 556   TREE_TYPE (t) = integer_type_node;
 557   return t;
 558 }
 559
 560 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
 561
 562 tree
 563 build_real (type, d)
 564      tree type;
 565      REAL_VALUE_TYPE d;
 566 {
 567   tree v;
 568   int overflow = 0;
 569
 570   /* Check for valid float value for this type on this target machine;
 571      if not, can print error message and store a valid value in D.  */
 572 #ifdef CHECK_FLOAT_VALUE
 573   CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
 574 #endif
 575
 576   v = make_node (REAL_CST);
 577   TREE_TYPE (v) = type;
 578   TREE_REAL_CST (v) = d;
 579   TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
 580   return v;
 581 }
 582
 583 /* Return a new REAL_CST node whose type is TYPE
 584    and whose value is the integer value of the INTEGER_CST node I.  */
 585
 586 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
 587
 588 REAL_VALUE_TYPE
 589 real_value_from_int_cst (type, i)
 590      tree type ATTRIBUTE_UNUSED, i;
 591 {
 592   REAL_VALUE_TYPE d;
 593
 594 #ifdef REAL_ARITHMETIC
 595   /* Clear all bits of the real value type so that we can later do
 596      bitwise comparisons to see if two values are the same.  */
 597   memset ((char *) &d, 0, sizeof d);
 598
 599   if (! TREE_UNSIGNED (TREE_TYPE (i)))
 600     REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
 601                          TYPE_MODE (type));
 602   else
 603     REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
 604                                   TREE_INT_CST_HIGH (i), TYPE_MODE (type));
 605 #else /* not REAL_ARITHMETIC */
 606   /* Some 386 compilers mishandle unsigned int to float conversions,
 607      so introduce a temporary variable E to avoid those bugs.  */
 608   if (TREE_INT_CST_HIGH (i) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i)))
 609     {
 610       REAL_VALUE_TYPE e;
 611
 612       d = (double) (~TREE_INT_CST_HIGH (i));
 613       e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
 614             * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
 615       d *= e;
 616       e = (double) (~TREE_INT_CST_LOW (i));
 617       d += e;
 618       d = (- d - 1.0);
 619     }
 620   else
 621     {
 622       REAL_VALUE_TYPE e;
 623
 624       d = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (i);
 625       e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
 626            * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
 627       d *= e;
 628       e = (double) TREE_INT_CST_LOW (i);
 629       d += e;
 630     }
 631 #endif /* not REAL_ARITHMETIC */
 632   return d;
 633 }
 634
 635 /* Args to pass to and from build_real_from_int_cst_1.  */
 636
 637 struct brfic_args
 638 {
 639   tree type;                    /* Input: type to conver to.  */
 640   tree i;                       /* Input: operand to convert.  */
 641   REAL_VALUE_TYPE d;            /* Output: floating point value.  */
 642 };
 643
 644 /* Convert an integer to a floating point value while protected by a floating
 645    point exception handler.  */
 646
 647 static void
 648 build_real_from_int_cst_1 (data)
 649      PTR data;
 650 {
 651   struct brfic_args *args = (struct brfic_args *) data;
 652
 653 #ifdef REAL_ARITHMETIC
 654   args->d = real_value_from_int_cst (args->type, args->i);
 655 #else
 656   args->d
 657     = REAL_VALUE_TRUNCATE (TYPE_MODE (args->type),
 658                            real_value_from_int_cst (args->type, args->i));
 659 #endif
 660 }
 661
 662 /* Given a tree representing an integer constant I, return a tree
 663    representing the same value as a floating-point constant of type TYPE.
 664    We cannot perform this operation if there is no way of doing arithmetic
 665    on floating-point values.  */
 666
 667 tree
 668 build_real_from_int_cst (type, i)
 669      tree type;
 670      tree i;
 671 {
 672   tree v;
 673   int overflow = TREE_OVERFLOW (i);
 674   REAL_VALUE_TYPE d;
 675   struct brfic_args args;
 676
 677   v = make_node (REAL_CST);
 678   TREE_TYPE (v) = type;
 679
 680   /* Setup input for build_real_from_int_cst_1() */
 681   args.type = type;
 682   args.i = i;
 683
 684   if (do_float_handler (build_real_from_int_cst_1, (PTR) &args))
 685     /* Receive output from build_real_from_int_cst_1() */
 686     d = args.d;
 687   else
 688     {
 689       /* We got an exception from build_real_from_int_cst_1() */
 690       d = dconst0;
 691       overflow = 1;
 692     }
 693
 694   /* Check for valid float value for this type on this target machine.  */
 695
 696 #ifdef CHECK_FLOAT_VALUE
 697   CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
 698 #endif
 699
 700   TREE_REAL_CST (v) = d;
 701   TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
 702   return v;
 703 }
 704
 705 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
 706
 707 /* Return a newly constructed STRING_CST node whose value is
 708    the LEN characters at STR.
 709    The TREE_TYPE is not initialized.  */
 710
 711 tree
 712 build_string (len, str)
 713      int len;
 714      const char *str;
 715 {
 716   register tree s = make_node (STRING_CST);
 717
 718   TREE_STRING_LENGTH (s) = len;
 719   TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
 720
 721   return s;
 722 }
 723
 724 /* Return a newly constructed COMPLEX_CST node whose value is
 725    specified by the real and imaginary parts REAL and IMAG.
 726    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
 727    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
 728
 729 tree
 730 build_complex (type, real, imag)
 731      tree type;
 732      tree real, imag;
 733 {
 734   register tree t = make_node (COMPLEX_CST);
 735
 736   TREE_REALPART (t) = real;
 737   TREE_IMAGPART (t) = imag;
 738   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
 739   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
 740   TREE_CONSTANT_OVERFLOW (t)
 741     = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
 742   return t;
 743 }
 744
 745 /* Build a newly constructed TREE_VEC node of length LEN.  */
 746
 747 tree
 748 make_tree_vec (len)
 749      int len;
 750 {
 751   register tree t;
 752   register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
 753
 754 #ifdef GATHER_STATISTICS
 755   tree_node_counts[(int)vec_kind]++;
 756   tree_node_sizes[(int)vec_kind] += length;
 757 #endif
 758
 759   t = ggc_alloc_tree (length);
 760
 761   memset ((PTR) t, 0, length);
 762   TREE_SET_CODE (t, TREE_VEC);
 763   TREE_VEC_LENGTH (t) = len;
 764
 765   return t;
 766 }
 767 \f
 768 /* Return 1 if EXPR is the integer constant zero or a complex constant
 769    of zero.  */
 770
 771 int
 772 integer_zerop (expr)
 773      tree expr;
 774 {
 775   STRIP_NOPS (expr);
 776
 777   return ((TREE_CODE (expr) == INTEGER_CST
 778            && ! TREE_CONSTANT_OVERFLOW (expr)
 779            && TREE_INT_CST_LOW (expr) == 0
 780            && TREE_INT_CST_HIGH (expr) == 0)
 781           || (TREE_CODE (expr) == COMPLEX_CST
 782               && integer_zerop (TREE_REALPART (expr))
 783               && integer_zerop (TREE_IMAGPART (expr))));
 784 }
 785
 786 /* Return 1 if EXPR is the integer constant one or the corresponding
 787    complex constant.  */
 788
 789 int
 790 integer_onep (expr)
 791      tree expr;
 792 {
 793   STRIP_NOPS (expr);
 794
 795   return ((TREE_CODE (expr) == INTEGER_CST
 796            && ! TREE_CONSTANT_OVERFLOW (expr)
 797            && TREE_INT_CST_LOW (expr) == 1
 798            && TREE_INT_CST_HIGH (expr) == 0)
 799           || (TREE_CODE (expr) == COMPLEX_CST
 800               && integer_onep (TREE_REALPART (expr))
 801               && integer_zerop (TREE_IMAGPART (expr))));
 802 }
 803
 804 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
 805    it contains.  Likewise for the corresponding complex constant.  */
 806
 807 int
 808 integer_all_onesp (expr)
 809      tree expr;
 810 {
 811   register int prec;
 812   register int uns;
 813
 814   STRIP_NOPS (expr);
 815
 816   if (TREE_CODE (expr) == COMPLEX_CST
 817       && integer_all_onesp (TREE_REALPART (expr))
 818       && integer_zerop (TREE_IMAGPART (expr)))
 819     return 1;
 820
 821   else if (TREE_CODE (expr) != INTEGER_CST
 822            || TREE_CONSTANT_OVERFLOW (expr))
 823     return 0;
 824
 825   uns = TREE_UNSIGNED (TREE_TYPE (expr));
 826   if (!uns)
 827     return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
 828             && TREE_INT_CST_HIGH (expr) == -1);
 829
 830   /* Note that using TYPE_PRECISION here is wrong.  We care about the
 831      actual bits, not the (arbitrary) range of the type.  */
 832   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
 833   if (prec >= HOST_BITS_PER_WIDE_INT)
 834     {
 835       HOST_WIDE_INT high_value;
 836       int shift_amount;
 837
 838       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
 839
 840       if (shift_amount > HOST_BITS_PER_WIDE_INT)
 841         /* Can not handle precisions greater than twice the host int size.  */
 842         abort ();
 843       else if (shift_amount == HOST_BITS_PER_WIDE_INT)
 844         /* Shifting by the host word size is undefined according to the ANSI
 845            standard, so we must handle this as a special case.  */
 846         high_value = -1;
 847       else
 848         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
 849
 850       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
 851               && TREE_INT_CST_HIGH (expr) == high_value);
 852     }
 853   else
 854     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
 855 }
 856
 857 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
 858    one bit on).  */
 859
 860 int
 861 integer_pow2p (expr)
 862      tree expr;
 863 {
 864   int prec;
 865   HOST_WIDE_INT high, low;
 866
 867   STRIP_NOPS (expr);
 868
 869   if (TREE_CODE (expr) == COMPLEX_CST
 870       && integer_pow2p (TREE_REALPART (expr))
 871       && integer_zerop (TREE_IMAGPART (expr)))
 872     return 1;
 873
 874   if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
 875     return 0;
 876
 877   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
 878           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
 879   high = TREE_INT_CST_HIGH (expr);
 880   low = TREE_INT_CST_LOW (expr);
 881
 882   /* First clear all bits that are beyond the type's precision in case
 883      we've been sign extended.  */
 884
 885   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 886     ;
 887   else if (prec > HOST_BITS_PER_WIDE_INT)
 888     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 889   else
 890     {
 891       high = 0;
 892       if (prec < HOST_BITS_PER_WIDE_INT)
 893         low &= ~((HOST_WIDE_INT) (-1) << prec);
 894     }
 895
 896   if (high == 0 && low == 0)
 897     return 0;
 898
 899   return ((high == 0 && (low & (low - 1)) == 0)
 900           || (low == 0 && (high & (high - 1)) == 0));
 901 }
 902
 903 /* Return the power of two represented by a tree node known to be a
 904    power of two.  */
 905
 906 int
 907 tree_log2 (expr)
 908      tree expr;
 909 {
 910   int prec;
 911   HOST_WIDE_INT high, low;
 912
 913   STRIP_NOPS (expr);
 914
 915   if (TREE_CODE (expr) == COMPLEX_CST)
 916     return tree_log2 (TREE_REALPART (expr));
 917
 918   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
 919           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
 920
 921   high = TREE_INT_CST_HIGH (expr);
 922   low = TREE_INT_CST_LOW (expr);
 923
 924   /* First clear all bits that are beyond the type's precision in case
 925      we've been sign extended.  */
 926
 927   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 928     ;
 929   else if (prec > HOST_BITS_PER_WIDE_INT)
 930     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 931   else
 932     {
 933       high = 0;
 934       if (prec < HOST_BITS_PER_WIDE_INT)
 935         low &= ~((HOST_WIDE_INT) (-1) << prec);
 936     }
 937
 938   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
 939           : exact_log2 (low));
 940 }
 941
 942 /* Similar, but return the largest integer Y such that 2 ** Y is less
 943    than or equal to EXPR.  */
 944
 945 int
 946 tree_floor_log2 (expr)
 947      tree expr;
 948 {
 949   int prec;
 950   HOST_WIDE_INT high, low;
 951
 952   STRIP_NOPS (expr);
 953
 954   if (TREE_CODE (expr) == COMPLEX_CST)
 955     return tree_log2 (TREE_REALPART (expr));
 956
 957   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
 958           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
 959
 960   high = TREE_INT_CST_HIGH (expr);
 961   low = TREE_INT_CST_LOW (expr);
 962
 963   /* First clear all bits that are beyond the type's precision in case
 964      we've been sign extended.  Ignore if type's precision hasn't been set
 965      since what we are doing is setting it.  */
 966
 967   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
 968     ;
 969   else if (prec > HOST_BITS_PER_WIDE_INT)
 970     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 971   else
 972     {
 973       high = 0;
 974       if (prec < HOST_BITS_PER_WIDE_INT)
 975         low &= ~((HOST_WIDE_INT) (-1) << prec);
 976     }
 977
 978   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
 979           : floor_log2 (low));
 980 }
 981
 982 /* Return 1 if EXPR is the real constant zero.  */
 983
 984 int
 985 real_zerop (expr)
 986      tree expr;
 987 {
 988   STRIP_NOPS (expr);
 989
 990   return ((TREE_CODE (expr) == REAL_CST
 991            && ! TREE_CONSTANT_OVERFLOW (expr)
 992            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
 993           || (TREE_CODE (expr) == COMPLEX_CST
 994               && real_zerop (TREE_REALPART (expr))
 995               && real_zerop (TREE_IMAGPART (expr))));
 996 }
 997
 998 /* Return 1 if EXPR is the real constant one in real or complex form.  */
 999
1000 int
1001 real_onep (expr)
1002      tree expr;
1003 {
1004   STRIP_NOPS (expr);
1005
1006   return ((TREE_CODE (expr) == REAL_CST
1007            && ! TREE_CONSTANT_OVERFLOW (expr)
1008            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
1009           || (TREE_CODE (expr) == COMPLEX_CST
1010               && real_onep (TREE_REALPART (expr))
1011               && real_zerop (TREE_IMAGPART (expr))));
1012 }
1013
1014 /* Return 1 if EXPR is the real constant two.  */
1015
1016 int
1017 real_twop (expr)
1018      tree expr;
1019 {
1020   STRIP_NOPS (expr);
1021
1022   return ((TREE_CODE (expr) == REAL_CST
1023            && ! TREE_CONSTANT_OVERFLOW (expr)
1024            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
1025           || (TREE_CODE (expr) == COMPLEX_CST
1026               && real_twop (TREE_REALPART (expr))
1027               && real_zerop (TREE_IMAGPART (expr))));
1028 }
1029
1030 /* Nonzero if EXP is a constant or a cast of a constant.  */
1031
1032 int
1033 really_constant_p (exp)
1034      tree exp;
1035 {
1036   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1037   while (TREE_CODE (exp) == NOP_EXPR
1038          || TREE_CODE (exp) == CONVERT_EXPR
1039          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1040     exp = TREE_OPERAND (exp, 0);
1041   return TREE_CONSTANT (exp);
1042 }
1043 \f
1044 /* Return first list element whose TREE_VALUE is ELEM.
1045    Return 0 if ELEM is not in LIST.  */
1046
1047 tree
1048 value_member (elem, list)
1049      tree elem, list;
1050 {
1051   while (list)
1052     {
1053       if (elem == TREE_VALUE (list))
1054         return list;
1055       list = TREE_CHAIN (list);
1056     }
1057   return NULL_TREE;
1058 }
1059
1060 /* Return first list element whose TREE_PURPOSE is ELEM.
1061    Return 0 if ELEM is not in LIST.  */
1062
1063 tree
1064 purpose_member (elem, list)
1065      tree elem, list;
1066 {
1067   while (list)
1068     {
1069       if (elem == TREE_PURPOSE (list))
1070         return list;
1071       list = TREE_CHAIN (list);
1072     }
1073   return NULL_TREE;
1074 }
1075
1076 /* Return first list element whose BINFO_TYPE is ELEM.
1077    Return 0 if ELEM is not in LIST.  */
1078
1079 tree
1080 binfo_member (elem, list)
1081      tree elem, list;
1082 {
1083   while (list)
1084     {
1085       if (elem == BINFO_TYPE (list))
1086         return list;
1087       list = TREE_CHAIN (list);
1088     }
1089   return NULL_TREE;
1090 }
1091
1092 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1093
1094 int
1095 chain_member (elem, chain)
1096      tree elem, chain;
1097 {
1098   while (chain)
1099     {
1100       if (elem == chain)
1101         return 1;
1102       chain = TREE_CHAIN (chain);
1103     }
1104
1105   return 0;
1106 }
1107
1108 /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of
1109    chain CHAIN.  This and the next function are currently unused, but
1110    are retained for completeness.  */
1111
1112 int
1113 chain_member_value (elem, chain)
1114      tree elem, chain;
1115 {
1116   while (chain)
1117     {
1118       if (elem == TREE_VALUE (chain))
1119         return 1;
1120       chain = TREE_CHAIN (chain);
1121     }
1122
1123   return 0;
1124 }
1125
1126 /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN)
1127    for any piece of chain CHAIN.  */
1128
1129 int
1130 chain_member_purpose (elem, chain)
1131      tree elem, chain;
1132 {
1133   while (chain)
1134     {
1135       if (elem == TREE_PURPOSE (chain))
1136         return 1;
1137       chain = TREE_CHAIN (chain);
1138     }
1139
1140   return 0;
1141 }
1142
1143 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1144    We expect a null pointer to mark the end of the chain.
1145    This is the Lisp primitive `length'.  */
1146
1147 int
1148 list_length (t)
1149      tree t;
1150 {
1151   register tree tail;
1152   register int len = 0;
1153
1154   for (tail = t; tail; tail = TREE_CHAIN (tail))
1155     len++;
1156
1157   return len;
1158 }
1159
1160 /* Returns the number of FIELD_DECLs in TYPE.  */
1161
1162 int
1163 fields_length (type)
1164      tree type;
1165 {
1166   tree t = TYPE_FIELDS (type);
1167   int count = 0;
1168
1169   for (; t; t = TREE_CHAIN (t))
1170     if (TREE_CODE (t) == FIELD_DECL)
1171       ++count;
1172
1173   return count;
1174 }
1175
1176 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1177    by modifying the last node in chain 1 to point to chain 2.
1178    This is the Lisp primitive `nconc'.  */
1179
1180 tree
1181 chainon (op1, op2)
1182      tree op1, op2;
1183 {
1184
1185   if (op1)
1186     {
1187       register tree t1;
1188 #ifdef ENABLE_TREE_CHECKING
1189       register tree t2;
1190 #endif
1191
1192       for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1193         ;
1194       TREE_CHAIN (t1) = op2;
1195 #ifdef ENABLE_TREE_CHECKING
1196       for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1197         if (t2 == t1)
1198           abort ();  /* Circularity created.  */
1199 #endif
1200       return op1;
1201     }
1202   else
1203     return op2;
1204 }
1205
1206 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
1207
1208 tree
1209 tree_last (chain)
1210      register tree chain;
1211 {
1212   register tree next;
1213   if (chain)
1214     while ((next = TREE_CHAIN (chain)))
1215       chain = next;
1216   return chain;
1217 }
1218
1219 /* Reverse the order of elements in the chain T,
1220    and return the new head of the chain (old last element).  */
1221
1222 tree
1223 nreverse (t)
1224      tree t;
1225 {
1226   register tree prev = 0, decl, next;
1227   for (decl = t; decl; decl = next)
1228     {
1229       next = TREE_CHAIN (decl);
1230       TREE_CHAIN (decl) = prev;
1231       prev = decl;
1232     }
1233   return prev;
1234 }
1235
1236 /* Given a chain CHAIN of tree nodes,
1237    construct and return a list of those nodes.  */
1238
1239 tree
1240 listify (chain)
1241      tree chain;
1242 {
1243   tree result = NULL_TREE;
1244   tree in_tail = chain;
1245   tree out_tail = NULL_TREE;
1246
1247   while (in_tail)
1248     {
1249       tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
1250       if (out_tail)
1251         TREE_CHAIN (out_tail) = next;
1252       else
1253         result = next;
1254       out_tail = next;
1255       in_tail = TREE_CHAIN (in_tail);
1256     }
1257
1258   return result;
1259 }
1260 \f
1261 /* Return a newly created TREE_LIST node whose
1262    purpose and value fields are PARM and VALUE.  */
1263
1264 tree
1265 build_tree_list (parm, value)
1266      tree parm, value;
1267 {
1268   register tree t = make_node (TREE_LIST);
1269   TREE_PURPOSE (t) = parm;
1270   TREE_VALUE (t) = value;
1271   return t;
1272 }
1273
1274 /* Return a newly created TREE_LIST node whose
1275    purpose and value fields are PARM and VALUE
1276    and whose TREE_CHAIN is CHAIN.  */
1277
1278 tree
1279 tree_cons (purpose, value, chain)
1280      tree purpose, value, chain;
1281 {
1282   register tree node;
1283
1284   node = ggc_alloc_tree (sizeof (struct tree_list));
1285
1286   memset (node, 0, sizeof (struct tree_common));
1287
1288 #ifdef GATHER_STATISTICS
1289   tree_node_counts[(int) x_kind]++;
1290   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
1291 #endif
1292
1293   TREE_SET_CODE (node, TREE_LIST);
1294   TREE_CHAIN (node) = chain;
1295   TREE_PURPOSE (node) = purpose;
1296   TREE_VALUE (node) = value;
1297   return node;
1298 }
1299
1300 \f
1301 /* Return the size nominally occupied by an object of type TYPE
1302    when it resides in memory.  The value is measured in units of bytes,
1303    and its data type is that normally used for type sizes
1304    (which is the first type created by make_signed_type or
1305    make_unsigned_type).  */
1306
1307 tree
1308 size_in_bytes (type)
1309      tree type;
1310 {
1311   tree t;
1312
1313   if (type == error_mark_node)
1314     return integer_zero_node;
1315
1316   type = TYPE_MAIN_VARIANT (type);
1317   t = TYPE_SIZE_UNIT (type);
1318
1319   if (t == 0)
1320     {
1321       incomplete_type_error (NULL_TREE, type);
1322       return size_zero_node;
1323     }
1324
1325   if (TREE_CODE (t) == INTEGER_CST)
1326     force_fit_type (t, 0);
1327
1328   return t;
1329 }
1330
1331 /* Return the size of TYPE (in bytes) as a wide integer
1332    or return -1 if the size can vary or is larger than an integer.  */
1333
1334 HOST_WIDE_INT
1335 int_size_in_bytes (type)
1336      tree type;
1337 {
1338   tree t;
1339
1340   if (type == error_mark_node)
1341     return 0;
1342
1343   type = TYPE_MAIN_VARIANT (type);
1344   t = TYPE_SIZE_UNIT (type);
1345   if (t == 0
1346       || TREE_CODE (t) != INTEGER_CST
1347       || TREE_OVERFLOW (t)
1348       || TREE_INT_CST_HIGH (t) != 0
1349       /* If the result would appear negative, it's too big to represent.  */
1350       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
1351     return -1;
1352
1353   return TREE_INT_CST_LOW (t);
1354 }
1355 \f
1356 /* Return the bit position of FIELD, in bits from the start of the record.
1357    This is a tree of type bitsizetype.  */
1358
1359 tree
1360 bit_position (field)
1361      tree field;
1362 {
1363
1364   return bit_from_pos (DECL_FIELD_OFFSET (field),
1365                        DECL_FIELD_BIT_OFFSET (field));
1366 }
1367
1368 /* Likewise, but return as an integer.  Abort if it cannot be represented
1369    in that way (since it could be a signed value, we don't have the option
1370    of returning -1 like int_size_in_byte can.  */
1371
1372 HOST_WIDE_INT
1373 int_bit_position (field)
1374      tree field;
1375 {
1376   return tree_low_cst (bit_position (field), 0);
1377 }
1378 \f
1379 /* Return the byte position of FIELD, in bytes from the start of the record.
1380    This is a tree of type sizetype.  */
1381
1382 tree
1383 byte_position (field)
1384      tree field;
1385 {
1386   return byte_from_pos (DECL_FIELD_OFFSET (field),
1387                         DECL_FIELD_BIT_OFFSET (field));
1388 }
1389
1390 /* Likewise, but return as an integer.  Abort if it cannot be represented
1391    in that way (since it could be a signed value, we don't have the option
1392    of returning -1 like int_size_in_byte can.  */
1393
1394 HOST_WIDE_INT
1395 int_byte_position (field)
1396      tree field;
1397 {
1398   return tree_low_cst (byte_position (field), 0);
1399 }
1400 \f
1401 /* Return the strictest alignment, in bits, that T is known to have.  */
1402
1403 unsigned int
1404 expr_align (t)
1405      tree t;
1406 {
1407   unsigned int align0, align1;
1408
1409   switch (TREE_CODE (t))
1410     {
1411     case NOP_EXPR:  case CONVERT_EXPR:  case NON_LVALUE_EXPR:
1412       /* If we have conversions, we know that the alignment of the
1413          object must meet each of the alignments of the types.  */
1414       align0 = expr_align (TREE_OPERAND (t, 0));
1415       align1 = TYPE_ALIGN (TREE_TYPE (t));
1416       return MAX (align0, align1);
1417
1418     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
1419     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
1420     case WITH_RECORD_EXPR:  case CLEANUP_POINT_EXPR:  case UNSAVE_EXPR:
1421       /* These don't change the alignment of an object.  */
1422       return expr_align (TREE_OPERAND (t, 0));
1423
1424     case COND_EXPR:
1425       /* The best we can do is say that the alignment is the least aligned
1426          of the two arms.  */
1427       align0 = expr_align (TREE_OPERAND (t, 1));
1428       align1 = expr_align (TREE_OPERAND (t, 2));
1429       return MIN (align0, align1);
1430
1431     case LABEL_DECL:     case CONST_DECL:
1432     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
1433       if (DECL_ALIGN (t) != 0)
1434         return DECL_ALIGN (t);
1435       break;
1436
1437     case FUNCTION_DECL:
1438       return FUNCTION_BOUNDARY;
1439
1440     default:
1441       break;
1442     }
1443
1444   /* Otherwise take the alignment from that of the type.  */
1445   return TYPE_ALIGN (TREE_TYPE (t));
1446 }
1447 \f
1448 /* Return, as a tree node, the number of elements for TYPE (which is an
1449    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
1450
1451 tree
1452 array_type_nelts (type)
1453      tree type;
1454 {
1455   tree index_type, min, max;
1456
1457   /* If they did it with unspecified bounds, then we should have already
1458      given an error about it before we got here.  */
1459   if (! TYPE_DOMAIN (type))
1460     return error_mark_node;
1461
1462   index_type = TYPE_DOMAIN (type);
1463   min = TYPE_MIN_VALUE (index_type);
1464   max = TYPE_MAX_VALUE (index_type);
1465
1466   return (integer_zerop (min)
1467           ? max
1468           : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
1469 }
1470 \f
1471 /* Return nonzero if arg is static -- a reference to an object in
1472    static storage.  This is not the same as the C meaning of `static'.  */
1473
1474 int
1475 staticp (arg)
1476      tree arg;
1477 {
1478   switch (TREE_CODE (arg))
1479     {
1480     case FUNCTION_DECL:
1481       /* Nested functions aren't static, since taking their address
1482          involves a trampoline.  */
1483       return (decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
1484         && ! DECL_NON_ADDR_CONST_P (arg);
1485
1486     case VAR_DECL:
1487       return (TREE_STATIC (arg) || DECL_EXTERNAL (arg))
1488         && ! DECL_NON_ADDR_CONST_P (arg);
1489
1490     case CONSTRUCTOR:
1491       return TREE_STATIC (arg);
1492
1493     case LABEL_DECL:
1494     case STRING_CST:
1495       return 1;
1496
1497       /* If we are referencing a bitfield, we can't evaluate an
1498          ADDR_EXPR at compile time and so it isn't a constant.  */
1499     case COMPONENT_REF:
1500       return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
1501               && staticp (TREE_OPERAND (arg, 0)));
1502
1503     case BIT_FIELD_REF:
1504       return 0;
1505
1506 #if 0
1507        /* This case is technically correct, but results in setting
1508           TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
1509           compile time.  */
1510     case INDIRECT_REF:
1511       return TREE_CONSTANT (TREE_OPERAND (arg, 0));
1512 #endif
1513
1514     case ARRAY_REF:
1515     case ARRAY_RANGE_REF:
1516       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1517           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1518         return staticp (TREE_OPERAND (arg, 0));
1519
1520     default:
1521       return 0;
1522     }
1523 }
1524 \f
1525 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1526    Do this to any expression which may be used in more than one place,
1527    but must be evaluated only once.
1528
1529    Normally, expand_expr would reevaluate the expression each time.
1530    Calling save_expr produces something that is evaluated and recorded
1531    the first time expand_expr is called on it.  Subsequent calls to
1532    expand_expr just reuse the recorded value.
1533
1534    The call to expand_expr that generates code that actually computes
1535    the value is the first call *at compile time*.  Subsequent calls
1536    *at compile time* generate code to use the saved value.
1537    This produces correct result provided that *at run time* control
1538    always flows through the insns made by the first expand_expr
1539    before reaching the other places where the save_expr was evaluated.
1540    You, the caller of save_expr, must make sure this is so.
1541
1542    Constants, and certain read-only nodes, are returned with no
1543    SAVE_EXPR because that is safe.  Expressions containing placeholders
1544    are not touched; see tree.def for an explanation of what these
1545    are used for.  */
1546
1547 tree
1548 save_expr (expr)
1549      tree expr;
1550 {
1551   register tree t = fold (expr);
1552
1553   /* We don't care about whether this can be used as an lvalue in this
1554      context.  */
1555   while (TREE_CODE (t) == NON_LVALUE_EXPR)
1556     t = TREE_OPERAND (t, 0);
1557
1558   /* If the tree evaluates to a constant, then we don't want to hide that
1559      fact (i.e. this allows further folding, and direct checks for constants).
1560      However, a read-only object that has side effects cannot be bypassed.
1561      Since it is no problem to reevaluate literals, we just return the
1562      literal node.  */
1563
1564   if (TREE_CONSTANT (t) || (TREE_READONLY (t) && ! TREE_SIDE_EFFECTS (t))
1565       || TREE_CODE (t) == SAVE_EXPR || TREE_CODE (t) == ERROR_MARK)
1566     return t;
1567
1568   /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1569      it means that the size or offset of some field of an object depends on
1570      the value within another field.
1571
1572      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1573      and some variable since it would then need to be both evaluated once and
1574      evaluated more than once.  Front-ends must assure this case cannot
1575      happen by surrounding any such subexpressions in their own SAVE_EXPR
1576      and forcing evaluation at the proper time.  */
1577   if (contains_placeholder_p (t))
1578     return t;
1579
1580   t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
1581
1582   /* This expression might be placed ahead of a jump to ensure that the
1583      value was computed on both sides of the jump.  So make sure it isn't
1584      eliminated as dead.  */
1585   TREE_SIDE_EFFECTS (t) = 1;
1586   TREE_READONLY (t) = 1;
1587   return t;
1588 }
1589
1590 /* Arrange for an expression to be expanded multiple independent
1591    times.  This is useful for cleanup actions, as the backend can
1592    expand them multiple times in different places.  */
1593
1594 tree
1595 unsave_expr (expr)
1596      tree expr;
1597 {
1598   tree t;
1599
1600   /* If this is already protected, no sense in protecting it again.  */
1601   if (TREE_CODE (expr) == UNSAVE_EXPR)
1602     return expr;
1603
1604   t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
1605   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
1606   return t;
1607 }
1608
1609 /* Returns the index of the first non-tree operand for CODE, or the number
1610    of operands if all are trees.  */
1611
1612 int
1613 first_rtl_op (code)
1614      enum tree_code code;
1615 {
1616   switch (code)
1617     {
1618     case SAVE_EXPR:
1619       return 2;
1620     case GOTO_SUBROUTINE_EXPR:
1621     case RTL_EXPR:
1622       return 0;
1623     case WITH_CLEANUP_EXPR:
1624       return 2;
1625     case METHOD_CALL_EXPR:
1626       return 3;
1627     default:
1628       return TREE_CODE_LENGTH (code);
1629     }
1630 }
1631
1632 /* Perform any modifications to EXPR required when it is unsaved.  Does
1633    not recurse into EXPR's subtrees.  */
1634
1635 void
1636 unsave_expr_1 (expr)
1637      tree expr;
1638 {
1639   switch (TREE_CODE (expr))
1640     {
1641     case SAVE_EXPR:
1642       if (! SAVE_EXPR_PERSISTENT_P (expr))
1643         SAVE_EXPR_RTL (expr) = 0;
1644       break;
1645
1646     case TARGET_EXPR:
1647       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
1648          It's OK for this to happen if it was part of a subtree that
1649          isn't immediately expanded, such as operand 2 of another
1650          TARGET_EXPR.  */
1651       if (TREE_OPERAND (expr, 1))
1652         break;
1653
1654       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
1655       TREE_OPERAND (expr, 3) = NULL_TREE;
1656       break;
1657
1658     case RTL_EXPR:
1659       /* I don't yet know how to emit a sequence multiple times.  */
1660       if (RTL_EXPR_SEQUENCE (expr) != 0)
1661         abort ();
1662       break;
1663
1664     default:
1665       if (lang_unsave_expr_now != 0)
1666         (*lang_unsave_expr_now) (expr);
1667       break;
1668     }
1669 }
1670
1671 /* Helper function for unsave_expr_now.  */
1672
1673 static void
1674 unsave_expr_now_r (expr)
1675      tree expr;
1676 {
1677   enum tree_code code;
1678
1679   /* There's nothing to do for NULL_TREE.  */
1680   if (expr == 0)
1681     return;
1682
1683   unsave_expr_1 (expr);
1684
1685   code = TREE_CODE (expr);
1686   switch (TREE_CODE_CLASS (code))
1687     {
1688     case 'c':  /* a constant */
1689     case 't':  /* a type node */
1690     case 'd':  /* A decl node */
1691     case 'b':  /* A block node */
1692       break;
1693
1694     case 'x':  /* miscellaneous: e.g., identifier, TREE_LIST or ERROR_MARK.  */
1695       if (code == TREE_LIST)
1696         {
1697           unsave_expr_now_r (TREE_VALUE (expr));
1698           unsave_expr_now_r (TREE_CHAIN (expr));
1699         }
1700       break;
1701
1702     case 'e':  /* an expression */
1703     case 'r':  /* a reference */
1704     case 's':  /* an expression with side effects */
1705     case '<':  /* a comparison expression */
1706     case '2':  /* a binary arithmetic expression */
1707     case '1':  /* a unary arithmetic expression */
1708       {
1709         int i;
1710
1711         for (i = first_rtl_op (code) - 1; i >= 0; i--)
1712           unsave_expr_now_r (TREE_OPERAND (expr, i));
1713       }
1714       break;
1715
1716     default:
1717       abort ();
1718     }
1719 }
1720
1721 /* Modify a tree in place so that all the evaluate only once things
1722    are cleared out.  Return the EXPR given.  */
1723
1724 tree
1725 unsave_expr_now (expr)
1726      tree expr;
1727 {
1728   if (lang_unsave!= 0)
1729     (*lang_unsave) (&expr);
1730   else
1731     unsave_expr_now_r (expr);
1732
1733   return expr;
1734 }
1735
1736 /* Return 0 if it is safe to evaluate EXPR multiple times,
1737    return 1 if it is safe if EXPR is unsaved afterward, or
1738    return 2 if it is completely unsafe.
1739
1740    This assumes that CALL_EXPRs and TARGET_EXPRs are never replicated in
1741    an expression tree, so that it safe to unsave them and the surrounding
1742    context will be correct.
1743
1744    SAVE_EXPRs basically *only* appear replicated in an expression tree,
1745    occasionally across the whole of a function.  It is therefore only
1746    safe to unsave a SAVE_EXPR if you know that all occurrences appear
1747    below the UNSAVE_EXPR.
1748
1749    RTL_EXPRs consume their rtl during evaluation.  It is therefore
1750    never possible to unsave them.  */
1751
1752 int
1753 unsafe_for_reeval (expr)
1754      tree expr;
1755 {
1756   int unsafeness = 0;
1757   enum tree_code code;
1758   int i, tmp;
1759   tree exp;
1760   int first_rtl;
1761
1762   if (expr == NULL_TREE)
1763     return 1;
1764
1765   code = TREE_CODE (expr);
1766   first_rtl = first_rtl_op (code);
1767
1768   switch (code)
1769     {
1770     case SAVE_EXPR:
1771     case RTL_EXPR:
1772       return 2;
1773
1774     case TREE_LIST:
1775       for (exp = expr; exp != 0; exp = TREE_CHAIN (exp))
1776         {
1777           tmp = unsafe_for_reeval (TREE_VALUE (exp));
1778           unsafeness = MAX (tmp, unsafeness);
1779         }
1780
1781       return unsafeness;
1782
1783     case CALL_EXPR:
1784       tmp = unsafe_for_reeval (TREE_OPERAND (expr, 1));
1785       return MAX (tmp, 1);
1786
1787     case TARGET_EXPR:
1788       unsafeness = 1;
1789       break;
1790
1791     default:
1792       if (lang_unsafe_for_reeval != 0)
1793         {
1794           tmp = (*lang_unsafe_for_reeval) (expr);
1795           if (tmp >= 0)
1796             return tmp;
1797         }
1798       break;
1799     }
1800
1801   switch (TREE_CODE_CLASS (code))
1802     {
1803     case 'c':  /* a constant */
1804     case 't':  /* a type node */
1805     case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
1806     case 'd':  /* A decl node */
1807     case 'b':  /* A block node */
1808       return 0;
1809
1810     case 'e':  /* an expression */
1811     case 'r':  /* a reference */
1812     case 's':  /* an expression with side effects */
1813     case '<':  /* a comparison expression */
1814     case '2':  /* a binary arithmetic expression */
1815     case '1':  /* a unary arithmetic expression */
1816       for (i = first_rtl - 1; i >= 0; i--)
1817         {
1818           tmp = unsafe_for_reeval (TREE_OPERAND (expr, i));
1819           unsafeness = MAX (tmp, unsafeness);
1820         }
1821
1822       return unsafeness;
1823
1824     default:
1825       return 2;
1826     }
1827 }
1828 \f
1829 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
1830    or offset that depends on a field within a record.  */
1831
1832 int
1833 contains_placeholder_p (exp)
1834      tree exp;
1835 {
1836   register enum tree_code code;
1837   int result;
1838
1839   if (!exp)
1840     return 0;
1841
1842   /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
1843      in it since it is supplying a value for it.  */
1844   code = TREE_CODE (exp);
1845   if (code == WITH_RECORD_EXPR)
1846     return 0;
1847   else if (code == PLACEHOLDER_EXPR)
1848     return 1;
1849
1850   switch (TREE_CODE_CLASS (code))
1851     {
1852     case 'r':
1853       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
1854          position computations since they will be converted into a
1855          WITH_RECORD_EXPR involving the reference, which will assume
1856          here will be valid.  */
1857       return contains_placeholder_p (TREE_OPERAND (exp, 0));
1858
1859     case 'x':
1860       if (code == TREE_LIST)
1861         return (contains_placeholder_p (TREE_VALUE (exp))
1862                 || (TREE_CHAIN (exp) != 0
1863                     && contains_placeholder_p (TREE_CHAIN (exp))));
1864       break;
1865
1866     case '1':
1867     case '2':  case '<':
1868     case 'e':
1869       switch (code)
1870         {
1871         case COMPOUND_EXPR:
1872           /* Ignoring the first operand isn't quite right, but works best.  */
1873           return contains_placeholder_p (TREE_OPERAND (exp, 1));
1874
1875         case RTL_EXPR:
1876         case CONSTRUCTOR:
1877           return 0;
1878
1879         case COND_EXPR:
1880           return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1881                   || contains_placeholder_p (TREE_OPERAND (exp, 1))
1882                   || contains_placeholder_p (TREE_OPERAND (exp, 2)));
1883
1884         case SAVE_EXPR:
1885           /* If we already know this doesn't have a placeholder, don't
1886              check again.  */
1887           if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
1888             return 0;
1889
1890           SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
1891           result = contains_placeholder_p (TREE_OPERAND (exp, 0));
1892           if (result)
1893             SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
1894
1895           return result;
1896
1897         case CALL_EXPR:
1898           return (TREE_OPERAND (exp, 1) != 0
1899                   && contains_placeholder_p (TREE_OPERAND (exp, 1)));
1900
1901         default:
1902           break;
1903         }
1904
1905       switch (TREE_CODE_LENGTH (code))
1906         {
1907         case 1:
1908           return contains_placeholder_p (TREE_OPERAND (exp, 0));
1909         case 2:
1910           return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1911                   || contains_placeholder_p (TREE_OPERAND (exp, 1)));
1912         default:
1913           return 0;
1914         }
1915
1916     default:
1917       return 0;
1918     }
1919   return 0;
1920 }
1921
1922 /* Return 1 if EXP contains any expressions that produce cleanups for an
1923    outer scope to deal with.  Used by fold.  */
1924
1925 int
1926 has_cleanups (exp)
1927      tree exp;
1928 {
1929   int i, nops, cmp;
1930
1931   if (! TREE_SIDE_EFFECTS (exp))
1932     return 0;
1933
1934   switch (TREE_CODE (exp))
1935     {
1936     case TARGET_EXPR:
1937     case GOTO_SUBROUTINE_EXPR:
1938     case WITH_CLEANUP_EXPR:
1939       return 1;
1940
1941     case CLEANUP_POINT_EXPR:
1942       return 0;
1943
1944     case CALL_EXPR:
1945       for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
1946         {
1947           cmp = has_cleanups (TREE_VALUE (exp));
1948           if (cmp)
1949             return cmp;
1950         }
1951       return 0;
1952
1953     default:
1954       break;
1955     }
1956
1957   /* This general rule works for most tree codes.  All exceptions should be
1958      handled above.  If this is a language-specific tree code, we can't
1959      trust what might be in the operand, so say we don't know
1960      the situation.  */
1961   if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
1962     return -1;
1963
1964   nops = first_rtl_op (TREE_CODE (exp));
1965   for (i = 0; i < nops; i++)
1966     if (TREE_OPERAND (exp, i) != 0)
1967       {
1968         int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
1969         if (type == 'e' || type == '<' || type == '1' || type == '2'
1970             || type == 'r' || type == 's')
1971           {
1972             cmp = has_cleanups (TREE_OPERAND (exp, i));
1973             if (cmp)
1974               return cmp;
1975           }
1976       }
1977
1978   return 0;
1979 }
1980 \f
1981 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
1982    return a tree with all occurrences of references to F in a
1983    PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
1984    contains only arithmetic expressions or a CALL_EXPR with a
1985    PLACEHOLDER_EXPR occurring only in its arglist.  */
1986
1987 tree
1988 substitute_in_expr (exp, f, r)
1989      tree exp;
1990      tree f;
1991      tree r;
1992 {
1993   enum tree_code code = TREE_CODE (exp);
1994   tree op0, op1, op2;
1995   tree new;
1996   tree inner;
1997
1998   switch (TREE_CODE_CLASS (code))
1999     {
2000     case 'c':
2001     case 'd':
2002       return exp;
2003
2004     case 'x':
2005       if (code == PLACEHOLDER_EXPR)
2006         return exp;
2007       else if (code == TREE_LIST)
2008         {
2009           op0 = (TREE_CHAIN (exp) == 0
2010                  ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
2011           op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
2012           if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2013             return exp;
2014
2015           return tree_cons (TREE_PURPOSE (exp), op1, op0);
2016         }
2017
2018       abort ();
2019
2020     case '1':
2021     case '2':
2022     case '<':
2023     case 'e':
2024       switch (TREE_CODE_LENGTH (code))
2025         {
2026         case 1:
2027           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2028           if (op0 == TREE_OPERAND (exp, 0))
2029             return exp;
2030
2031           if (code == NON_LVALUE_EXPR)
2032             return op0;
2033
2034           new = fold (build1 (code, TREE_TYPE (exp), op0));
2035           break;
2036
2037         case 2:
2038           /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2039              could, but we don't support it.  */
2040           if (code == RTL_EXPR)
2041             return exp;
2042           else if (code == CONSTRUCTOR)
2043             abort ();
2044
2045           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2046           op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2047           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2048             return exp;
2049
2050           new = fold (build (code, TREE_TYPE (exp), op0, op1));
2051           break;
2052
2053         case 3:
2054           /* It cannot be that anything inside a SAVE_EXPR contains a
2055              PLACEHOLDER_EXPR.  */
2056           if (code == SAVE_EXPR)
2057             return exp;
2058
2059           else if (code == CALL_EXPR)
2060             {
2061               op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2062               if (op1 == TREE_OPERAND (exp, 1))
2063                 return exp;
2064
2065               return build (code, TREE_TYPE (exp),
2066                             TREE_OPERAND (exp, 0), op1, NULL_TREE);
2067             }
2068
2069           else if (code != COND_EXPR)
2070             abort ();
2071
2072           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2073           op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2074           op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2075           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2076               && op2 == TREE_OPERAND (exp, 2))
2077             return exp;
2078
2079           new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2080           break;
2081
2082         default:
2083           abort ();
2084         }
2085
2086       break;
2087
2088     case 'r':
2089       switch (code)
2090         {
2091         case COMPONENT_REF:
2092           /* If this expression is getting a value from a PLACEHOLDER_EXPR
2093              and it is the right field, replace it with R.  */
2094           for (inner = TREE_OPERAND (exp, 0);
2095                TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
2096                inner = TREE_OPERAND (inner, 0))
2097             ;
2098           if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2099               && TREE_OPERAND (exp, 1) == f)
2100             return r;
2101
2102           /* If this expression hasn't been completed let, leave it
2103              alone.  */
2104           if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2105               && TREE_TYPE (inner) == 0)
2106             return exp;
2107
2108           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2109           if (op0 == TREE_OPERAND (exp, 0))
2110             return exp;
2111
2112           new = fold (build (code, TREE_TYPE (exp), op0,
2113                              TREE_OPERAND (exp, 1)));
2114           break;
2115
2116         case BIT_FIELD_REF:
2117           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2118           op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2119           op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2120           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2121               && op2 == TREE_OPERAND (exp, 2))
2122             return exp;
2123
2124           new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2125           break;
2126
2127         case INDIRECT_REF:
2128         case BUFFER_REF:
2129           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2130           if (op0 == TREE_OPERAND (exp, 0))
2131             return exp;
2132
2133           new = fold (build1 (code, TREE_TYPE (exp), op0));
2134           break;
2135
2136         default:
2137           abort ();
2138         }
2139       break;
2140
2141     default:
2142       abort ();
2143     }
2144
2145   TREE_READONLY (new) = TREE_READONLY (exp);
2146   return new;
2147 }
2148 \f
2149 /* Stabilize a reference so that we can use it any number of times
2150    without causing its operands to be evaluated more than once.
2151    Returns the stabilized reference.  This works by means of save_expr,
2152    so see the caveats in the comments about save_expr.
2153
2154    Also allows conversion expressions whose operands are references.
2155    Any other kind of expression is returned unchanged.  */
2156
2157 tree
2158 stabilize_reference (ref)
2159      tree ref;
2160 {
2161   register tree result;
2162   register enum tree_code code = TREE_CODE (ref);
2163
2164   switch (code)
2165     {
2166     case VAR_DECL:
2167     case PARM_DECL:
2168     case RESULT_DECL:
2169       /* No action is needed in this case.  */
2170       return ref;
2171
2172     case NOP_EXPR:
2173     case CONVERT_EXPR:
2174     case FLOAT_EXPR:
2175     case FIX_TRUNC_EXPR:
2176     case FIX_FLOOR_EXPR:
2177     case FIX_ROUND_EXPR:
2178     case FIX_CEIL_EXPR:
2179       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2180       break;
2181
2182     case INDIRECT_REF:
2183       result = build_nt (INDIRECT_REF,
2184                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2185       break;
2186
2187     case COMPONENT_REF:
2188       result = build_nt (COMPONENT_REF,
2189                          stabilize_reference (TREE_OPERAND (ref, 0)),
2190                          TREE_OPERAND (ref, 1));
2191       break;
2192
2193     case BIT_FIELD_REF:
2194       result = build_nt (BIT_FIELD_REF,
2195                          stabilize_reference (TREE_OPERAND (ref, 0)),
2196                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2197                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2198       break;
2199
2200     case ARRAY_REF:
2201       result = build_nt (ARRAY_REF,
2202                          stabilize_reference (TREE_OPERAND (ref, 0)),
2203                          stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2204       break;
2205
2206     case ARRAY_RANGE_REF:
2207       result = build_nt (ARRAY_RANGE_REF,
2208                          stabilize_reference (TREE_OPERAND (ref, 0)),
2209                          stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2210       break;
2211
2212     case COMPOUND_EXPR:
2213       /* We cannot wrap the first expression in a SAVE_EXPR, as then
2214          it wouldn't be ignored.  This matters when dealing with
2215          volatiles.  */
2216       return stabilize_reference_1 (ref);
2217
2218     case RTL_EXPR:
2219       result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2220                        save_expr (build1 (ADDR_EXPR,
2221                                           build_pointer_type (TREE_TYPE (ref)),
2222                                           ref)));
2223       break;
2224
2225       /* If arg isn't a kind of lvalue we recognize, make no change.
2226          Caller should recognize the error for an invalid lvalue.  */
2227     default:
2228       return ref;
2229
2230     case ERROR_MARK:
2231       return error_mark_node;
2232     }
2233
2234   TREE_TYPE (result) = TREE_TYPE (ref);
2235   TREE_READONLY (result) = TREE_READONLY (ref);
2236   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2237   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2238
2239   return result;
2240 }
2241
2242 /* Subroutine of stabilize_reference; this is called for subtrees of
2243    references.  Any expression with side-effects must be put in a SAVE_EXPR
2244    to ensure that it is only evaluated once.
2245
2246    We don't put SAVE_EXPR nodes around everything, because assigning very
2247    simple expressions to temporaries causes us to miss good opportunities
2248    for optimizations.  Among other things, the opportunity to fold in the
2249    addition of a constant into an addressing mode often gets lost, e.g.
2250    "y[i+1] += x;".  In general, we take the approach that we should not make
2251    an assignment unless we are forced into it - i.e., that any non-side effect
2252    operator should be allowed, and that cse should take care of coalescing
2253    multiple utterances of the same expression should that prove fruitful.  */
2254
2255 tree
2256 stabilize_reference_1 (e)
2257      tree e;
2258 {
2259   register tree result;
2260   register enum tree_code code = TREE_CODE (e);
2261
2262   /* We cannot ignore const expressions because it might be a reference
2263      to a const array but whose index contains side-effects.  But we can
2264      ignore things that are actual constant or that already have been
2265      handled by this function.  */
2266
2267   if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2268     return e;
2269
2270   switch (TREE_CODE_CLASS (code))
2271     {
2272     case 'x':
2273     case 't':
2274     case 'd':
2275     case 'b':
2276     case '<':
2277     case 's':
2278     case 'e':
2279     case 'r':
2280       /* If the expression has side-effects, then encase it in a SAVE_EXPR
2281          so that it will only be evaluated once.  */
2282       /* The reference (r) and comparison (<) classes could be handled as
2283          below, but it is generally faster to only evaluate them once.  */
2284       if (TREE_SIDE_EFFECTS (e))
2285         return save_expr (e);
2286       return e;
2287
2288     case 'c':
2289       /* Constants need no processing.  In fact, we should never reach
2290          here.  */
2291       return e;
2292
2293     case '2':
2294       /* Division is slow and tends to be compiled with jumps,
2295          especially the division by powers of 2 that is often
2296          found inside of an array reference.  So do it just once.  */
2297       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2298           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2299           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2300           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2301         return save_expr (e);
2302       /* Recursively stabilize each operand.  */
2303       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2304                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
2305       break;
2306
2307     case '1':
2308       /* Recursively stabilize each operand.  */
2309       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2310       break;
2311
2312     default:
2313       abort ();
2314     }
2315
2316   TREE_TYPE (result) = TREE_TYPE (e);
2317   TREE_READONLY (result) = TREE_READONLY (e);
2318   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2319   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2320
2321   return result;
2322 }
2323 \f
2324 /* Low-level constructors for expressions.  */
2325
2326 /* Build an expression of code CODE, data type TYPE,
2327    and operands as specified by the arguments ARG1 and following arguments.
2328    Expressions and reference nodes can be created this way.
2329    Constants, decls, types and misc nodes cannot be.  */
2330
2331 tree
2332 build VPARAMS ((enum tree_code code, tree tt, ...))
2333 {
2334   register tree t;
2335   register int length;
2336   register int i;
2337   int fro;
2338   int constant;
2339
2340   VA_OPEN (p, tt);
2341   VA_FIXEDARG (p, enum tree_code, code);
2342   VA_FIXEDARG (p, tree, tt);
2343
2344   t = make_node (code);
2345   length = TREE_CODE_LENGTH (code);
2346   TREE_TYPE (t) = tt;
2347
2348   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2349      result based on those same flags for the arguments.  But if the
2350      arguments aren't really even `tree' expressions, we shouldn't be trying
2351      to do this.  */
2352   fro = first_rtl_op (code);
2353
2354   /* Expressions without side effects may be constant if their
2355      arguments are as well.  */
2356   constant = (TREE_CODE_CLASS (code) == '<'
2357               || TREE_CODE_CLASS (code) == '1'
2358               || TREE_CODE_CLASS (code) == '2'
2359               || TREE_CODE_CLASS (code) == 'c');
2360
2361   if (length == 2)
2362     {
2363       /* This is equivalent to the loop below, but faster.  */
2364       register tree arg0 = va_arg (p, tree);
2365       register tree arg1 = va_arg (p, tree);
2366
2367       TREE_OPERAND (t, 0) = arg0;
2368       TREE_OPERAND (t, 1) = arg1;
2369       TREE_READONLY (t) = 1;
2370       if (arg0 && fro > 0)
2371         {
2372           if (TREE_SIDE_EFFECTS (arg0))
2373             TREE_SIDE_EFFECTS (t) = 1;
2374           if (!TREE_READONLY (arg0))
2375             TREE_READONLY (t) = 0;
2376           if (!TREE_CONSTANT (arg0))
2377             constant = 0;
2378         }
2379
2380       if (arg1 && fro > 1)
2381         {
2382           if (TREE_SIDE_EFFECTS (arg1))
2383             TREE_SIDE_EFFECTS (t) = 1;
2384           if (!TREE_READONLY (arg1))
2385             TREE_READONLY (t) = 0;
2386           if (!TREE_CONSTANT (arg1))
2387             constant = 0;
2388         }
2389     }
2390   else if (length == 1)
2391     {
2392       register tree arg0 = va_arg (p, tree);
2393
2394       /* The only one-operand cases we handle here are those with side-effects.
2395          Others are handled with build1.  So don't bother checked if the
2396          arg has side-effects since we'll already have set it.
2397
2398          ??? This really should use build1 too.  */
2399       if (TREE_CODE_CLASS (code) != 's')
2400         abort ();
2401       TREE_OPERAND (t, 0) = arg0;
2402     }
2403   else
2404     {
2405       for (i = 0; i < length; i++)
2406         {
2407           register tree operand = va_arg (p, tree);
2408
2409           TREE_OPERAND (t, i) = operand;
2410           if (operand && fro > i)
2411             {
2412               if (TREE_SIDE_EFFECTS (operand))
2413                 TREE_SIDE_EFFECTS (t) = 1;
2414               if (!TREE_CONSTANT (operand))
2415                 constant = 0;
2416             }
2417         }
2418     }
2419   VA_CLOSE (p);
2420
2421   TREE_CONSTANT (t) = constant;
2422   return t;
2423 }
2424
2425 /* Same as above, but only builds for unary operators.
2426    Saves lions share of calls to `build'; cuts down use
2427    of varargs, which is expensive for RISC machines.  */
2428
2429 tree
2430 build1 (code, type, node)
2431      enum tree_code code;
2432      tree type;
2433      tree node;
2434 {
2435   register int length;
2436 #ifdef GATHER_STATISTICS
2437   register tree_node_kind kind;
2438 #endif
2439   register tree t;
2440
2441 #ifdef GATHER_STATISTICS
2442   if (TREE_CODE_CLASS (code) == 'r')
2443     kind = r_kind;
2444   else
2445     kind = e_kind;
2446 #endif
2447
2448 #ifdef ENABLE_CHECKING
2449   if (TREE_CODE_CLASS (code) == '2'
2450       || TREE_CODE_CLASS (code) == '<'
2451       || TREE_CODE_LENGTH (code) != 1)
2452     abort ();
2453 #endif /* ENABLE_CHECKING */
2454
2455   length = sizeof (struct tree_exp);
2456
2457   t = ggc_alloc_tree (length);
2458
2459   memset ((PTR) t, 0, sizeof (struct tree_common));
2460
2461 #ifdef GATHER_STATISTICS
2462   tree_node_counts[(int) kind]++;
2463   tree_node_sizes[(int) kind] += length;
2464 #endif
2465
2466   TREE_SET_CODE (t, code);
2467
2468   TREE_TYPE (t) = type;
2469   TREE_COMPLEXITY (t) = 0;
2470   TREE_OPERAND (t, 0) = node;
2471   if (node && first_rtl_op (code) != 0)
2472     {
2473       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
2474       TREE_READONLY (t) = TREE_READONLY (node);
2475     }
2476
2477   switch (code)
2478     {
2479     case INIT_EXPR:
2480     case MODIFY_EXPR:
2481     case VA_ARG_EXPR:
2482     case RTL_EXPR:
2483     case PREDECREMENT_EXPR:
2484     case PREINCREMENT_EXPR:
2485     case POSTDECREMENT_EXPR:
2486     case POSTINCREMENT_EXPR:
2487       /* All of these have side-effects, no matter what their
2488          operands are.  */
2489       TREE_SIDE_EFFECTS (t) = 1;
2490       TREE_READONLY (t) = 0;
2491       break;
2492
2493     default:
2494       if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
2495         TREE_CONSTANT (t) = 1;
2496       break;
2497     }
2498
2499   return t;
2500 }
2501
2502 /* Similar except don't specify the TREE_TYPE
2503    and leave the TREE_SIDE_EFFECTS as 0.
2504    It is permissible for arguments to be null,
2505    or even garbage if their values do not matter.  */
2506
2507 tree
2508 build_nt VPARAMS ((enum tree_code code, ...))
2509 {
2510   register tree t;
2511   register int length;
2512   register int i;
2513
2514   VA_OPEN (p, code);
2515   VA_FIXEDARG (p, enum tree_code, code);
2516
2517   t = make_node (code);
2518   length = TREE_CODE_LENGTH (code);
2519
2520   for (i = 0; i < length; i++)
2521     TREE_OPERAND (t, i) = va_arg (p, tree);
2522
2523   VA_CLOSE (p);
2524   return t;
2525 }
2526 \f
2527 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
2528    We do NOT enter this node in any sort of symbol table.
2529
2530    layout_decl is used to set up the decl's storage layout.
2531    Other slots are initialized to 0 or null pointers.  */
2532
2533 tree
2534 build_decl (code, name, type)
2535      enum tree_code code;
2536      tree name, type;
2537 {
2538   register tree t;
2539
2540   t = make_node (code);
2541
2542 /*  if (type == error_mark_node)
2543     type = integer_type_node; */
2544 /* That is not done, deliberately, so that having error_mark_node
2545    as the type can suppress useless errors in the use of this variable.  */
2546
2547   DECL_NAME (t) = name;
2548   TREE_TYPE (t) = type;
2549
2550   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
2551     layout_decl (t, 0);
2552   else if (code == FUNCTION_DECL)
2553     DECL_MODE (t) = FUNCTION_MODE;
2554
2555   return t;
2556 }
2557 \f
2558 /* BLOCK nodes are used to represent the structure of binding contours
2559    and declarations, once those contours have been exited and their contents
2560    compiled.  This information is used for outputting debugging info.  */
2561
2562 tree
2563 build_block (vars, tags, subblocks, supercontext, chain)
2564      tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
2565 {
2566   register tree block = make_node (BLOCK);
2567
2568   BLOCK_VARS (block) = vars;
2569   BLOCK_SUBBLOCKS (block) = subblocks;
2570   BLOCK_SUPERCONTEXT (block) = supercontext;
2571   BLOCK_CHAIN (block) = chain;
2572   return block;
2573 }
2574
2575 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
2576    location where an expression or an identifier were encountered. It
2577    is necessary for languages where the frontend parser will handle
2578    recursively more than one file (Java is one of them).  */
2579
2580 tree
2581 build_expr_wfl (node, file, line, col)
2582      tree node;
2583      const char *file;
2584      int line, col;
2585 {
2586   static const char *last_file = 0;
2587   static tree last_filenode = NULL_TREE;
2588   register tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
2589
2590   EXPR_WFL_NODE (wfl) = node;
2591   EXPR_WFL_SET_LINECOL (wfl, line, col);
2592   if (file != last_file)
2593     {
2594       last_file = file;
2595       last_filenode = file ? get_identifier (file) : NULL_TREE;
2596     }
2597
2598   EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
2599   if (node)
2600     {
2601       TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
2602       TREE_TYPE (wfl) = TREE_TYPE (node);
2603     }
2604
2605   return wfl;
2606 }
2607 \f
2608 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
2609    is ATTRIBUTE.  */
2610
2611 tree
2612 build_decl_attribute_variant (ddecl, attribute)
2613      tree ddecl, attribute;
2614 {
2615   DECL_ATTRIBUTES (ddecl) = attribute;
2616   return ddecl;
2617 }
2618
2619 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
2620    is ATTRIBUTE.
2621
2622    Record such modified types already made so we don't make duplicates.  */
2623
2624 tree
2625 build_type_attribute_variant (ttype, attribute)
2626      tree ttype, attribute;
2627 {
2628   if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
2629     {
2630       unsigned int hashcode;
2631       tree ntype;
2632
2633       ntype = copy_node (ttype);
2634
2635       TYPE_POINTER_TO (ntype) = 0;
2636       TYPE_REFERENCE_TO (ntype) = 0;
2637       TYPE_ATTRIBUTES (ntype) = attribute;
2638
2639       /* Create a new main variant of TYPE.  */
2640       TYPE_MAIN_VARIANT (ntype) = ntype;
2641       TYPE_NEXT_VARIANT (ntype) = 0;
2642       set_type_quals (ntype, TYPE_UNQUALIFIED);
2643
2644       hashcode = (TYPE_HASH (TREE_CODE (ntype))
2645                   + TYPE_HASH (TREE_TYPE (ntype))
2646                   + attribute_hash_list (attribute));
2647
2648       switch (TREE_CODE (ntype))
2649         {
2650         case FUNCTION_TYPE:
2651           hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
2652           break;
2653         case ARRAY_TYPE:
2654           hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
2655           break;
2656         case INTEGER_TYPE:
2657           hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
2658           break;
2659         case REAL_TYPE:
2660           hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
2661           break;
2662         default:
2663           break;
2664         }
2665
2666       ntype = type_hash_canon (hashcode, ntype);
2667       ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
2668     }
2669
2670   return ttype;
2671 }
2672
2673 /* Default value of targetm.comp_type_attributes that always returns 1.  */
2674
2675 int
2676 default_comp_type_attributes (type1, type2)
2677      tree type1 ATTRIBUTE_UNUSED;
2678      tree type2 ATTRIBUTE_UNUSED;
2679 {
2680   return 1;
2681 }
2682
2683 /* Default version of targetm.set_default_type_attributes that always does
2684    nothing.  */
2685
2686 void
2687 default_set_default_type_attributes (type)
2688      tree type ATTRIBUTE_UNUSED;
2689 {
2690 }
2691
2692 /* Default version of targetm.insert_attributes that always does nothing.  */
2693 void
2694 default_insert_attributes (decl, attr_ptr)
2695      tree decl ATTRIBUTE_UNUSED;
2696      tree *attr_ptr ATTRIBUTE_UNUSED;
2697 {
2698 }
2699
2700 /* Default value of targetm.attribute_table that is empty.  */
2701 const struct attribute_spec default_target_attribute_table[] =
2702 {
2703   { NULL, 0, 0, false, false, false, NULL }
2704 };
2705
2706 /* Default value of targetm.function_attribute_inlinable_p that always
2707    returns false.  */
2708 bool
2709 default_function_attribute_inlinable_p (fndecl)
2710      tree fndecl ATTRIBUTE_UNUSED;
2711 {
2712   /* By default, functions with machine attributes cannot be inlined.  */
2713   return false;
2714 }
2715
2716 /* Return non-zero if IDENT is a valid name for attribute ATTR,
2717    or zero if not.
2718
2719    We try both `text' and `__text__', ATTR may be either one.  */
2720 /* ??? It might be a reasonable simplification to require ATTR to be only
2721    `text'.  One might then also require attribute lists to be stored in
2722    their canonicalized form.  */
2723
2724 int
2725 is_attribute_p (attr, ident)
2726      const char *attr;
2727      tree ident;
2728 {
2729   int ident_len, attr_len;
2730   const char *p;
2731
2732   if (TREE_CODE (ident) != IDENTIFIER_NODE)
2733     return 0;
2734
2735   if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
2736     return 1;
2737
2738   p = IDENTIFIER_POINTER (ident);
2739   ident_len = strlen (p);
2740   attr_len = strlen (attr);
2741
2742   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
2743   if (attr[0] == '_')
2744     {
2745       if (attr[1] != '_'
2746           || attr[attr_len - 2] != '_'
2747           || attr[attr_len - 1] != '_')
2748         abort ();
2749       if (ident_len == attr_len - 4
2750           && strncmp (attr + 2, p, attr_len - 4) == 0)
2751         return 1;
2752     }
2753   else
2754     {
2755       if (ident_len == attr_len + 4
2756           && p[0] == '_' && p[1] == '_'
2757           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
2758           && strncmp (attr, p + 2, attr_len) == 0)
2759         return 1;
2760     }
2761
2762   return 0;
2763 }
2764
2765 /* Given an attribute name and a list of attributes, return a pointer to the
2766    attribute's list element if the attribute is part of the list, or NULL_TREE
2767    if not found.  If the attribute appears more than once, this only
2768    returns the first occurance; the TREE_CHAIN of the return value should
2769    be passed back in if further occurances are wanted.  */
2770
2771 tree
2772 lookup_attribute (attr_name, list)
2773      const char *attr_name;
2774      tree list;
2775 {
2776   tree l;
2777
2778   for (l = list; l; l = TREE_CHAIN (l))
2779     {
2780       if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
2781         abort ();
2782       if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
2783         return l;
2784     }
2785
2786   return NULL_TREE;
2787 }
2788
2789 /* Return an attribute list that is the union of a1 and a2.  */
2790
2791 tree
2792 merge_attributes (a1, a2)
2793      register tree a1, a2;
2794 {
2795   tree attributes;
2796
2797   /* Either one unset?  Take the set one.  */
2798
2799   if ((attributes = a1) == 0)
2800     attributes = a2;
2801
2802   /* One that completely contains the other?  Take it.  */
2803
2804   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
2805     {
2806       if (attribute_list_contained (a2, a1))
2807         attributes = a2;
2808       else
2809         {
2810           /* Pick the longest list, and hang on the other list.  */
2811
2812           if (list_length (a1) < list_length (a2))
2813             attributes = a2, a2 = a1;
2814
2815           for (; a2 != 0; a2 = TREE_CHAIN (a2))
2816             {
2817               tree a;
2818               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2819                                          attributes);
2820                    a != NULL_TREE;
2821                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2822                                          TREE_CHAIN (a)))
2823                 {
2824                   if (simple_cst_equal (TREE_VALUE (a), TREE_VALUE (a2)) == 1)
2825                     break;
2826                 }
2827               if (a == NULL_TREE)
2828                 {
2829                   a1 = copy_node (a2);
2830                   TREE_CHAIN (a1) = attributes;
2831                   attributes = a1;
2832                 }
2833             }
2834         }
2835     }
2836   return attributes;
2837 }
2838
2839 /* Given types T1 and T2, merge their attributes and return
2840   the result.  */
2841
2842 tree
2843 merge_type_attributes (t1, t2)
2844      tree t1, t2;
2845 {
2846   return merge_attributes (TYPE_ATTRIBUTES (t1),
2847                            TYPE_ATTRIBUTES (t2));
2848 }
2849
2850 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
2851    the result.  */
2852
2853 tree
2854 merge_decl_attributes (olddecl, newdecl)
2855      tree olddecl, newdecl;
2856 {
2857   return merge_attributes (DECL_ATTRIBUTES (olddecl),
2858                            DECL_ATTRIBUTES (newdecl));
2859 }
2860
2861 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
2862
2863 /* Specialization of merge_decl_attributes for various Windows targets.
2864
2865    This handles the following situation:
2866
2867      __declspec (dllimport) int foo;
2868      int foo;
2869
2870    The second instance of `foo' nullifies the dllimport.  */
2871
2872 tree
2873 merge_dllimport_decl_attributes (old, new)
2874      tree old;
2875      tree new;
2876 {
2877   tree a;
2878   int delete_dllimport_p;
2879
2880   old = DECL_ATTRIBUTES (old);
2881   new = DECL_ATTRIBUTES (new);
2882
2883   /* What we need to do here is remove from `old' dllimport if it doesn't
2884      appear in `new'.  dllimport behaves like extern: if a declaration is
2885      marked dllimport and a definition appears later, then the object
2886      is not dllimport'd.  */
2887   if (lookup_attribute ("dllimport", old) != NULL_TREE
2888       && lookup_attribute ("dllimport", new) == NULL_TREE)
2889     delete_dllimport_p = 1;
2890   else
2891     delete_dllimport_p = 0;
2892
2893   a = merge_attributes (old, new);
2894
2895   if (delete_dllimport_p)
2896     {
2897       tree prev,t;
2898
2899       /* Scan the list for dllimport and delete it.  */
2900       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
2901         {
2902           if (is_attribute_p ("dllimport", TREE_PURPOSE (t)))
2903             {
2904               if (prev == NULL_TREE)
2905                 a = TREE_CHAIN (a);
2906               else
2907                 TREE_CHAIN (prev) = TREE_CHAIN (t);
2908               break;
2909             }
2910         }
2911     }
2912
2913   return a;
2914 }
2915
2916 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
2917 \f
2918 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
2919    of the various TYPE_QUAL values.  */
2920
2921 static void
2922 set_type_quals (type, type_quals)
2923      tree type;
2924      int type_quals;
2925 {
2926   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
2927   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
2928   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
2929 }
2930
2931 /* Return a version of the TYPE, qualified as indicated by the
2932    TYPE_QUALS, if one exists.  If no qualified version exists yet,
2933    return NULL_TREE.  */
2934
2935 tree
2936 get_qualified_type (type, type_quals)
2937      tree type;
2938      int type_quals;
2939 {
2940   tree t;
2941
2942   /* Search the chain of variants to see if there is already one there just
2943      like the one we need to have.  If so, use that existing one.  We must
2944      preserve the TYPE_NAME, since there is code that depends on this.  */
2945   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2946     if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type))
2947       return t;
2948
2949   return NULL_TREE;
2950 }
2951
2952 /* Like get_qualified_type, but creates the type if it does not
2953    exist.  This function never returns NULL_TREE.  */
2954
2955 tree
2956 build_qualified_type (type, type_quals)
2957      tree type;
2958      int type_quals;
2959 {
2960   tree t;
2961
2962   /* See if we already have the appropriate qualified variant.  */
2963   t = get_qualified_type (type, type_quals);
2964
2965   /* If not, build it.  */
2966   if (!t)
2967     {
2968       t = build_type_copy (type);
2969       set_type_quals (t, type_quals);
2970     }
2971
2972   return t;
2973 }
2974
2975 /* Create a new variant of TYPE, equivalent but distinct.
2976    This is so the caller can modify it.  */
2977
2978 tree
2979 build_type_copy (type)
2980      tree type;
2981 {
2982   register tree t, m = TYPE_MAIN_VARIANT (type);
2983
2984   t = copy_node (type);
2985
2986   TYPE_POINTER_TO (t) = 0;
2987   TYPE_REFERENCE_TO (t) = 0;
2988
2989   /* Add this type to the chain of variants of TYPE.  */
2990   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
2991   TYPE_NEXT_VARIANT (m) = t;
2992
2993   return t;
2994 }
2995 \f
2996 /* Hashing of types so that we don't make duplicates.
2997    The entry point is `type_hash_canon'.  */
2998
2999 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
3000    with types in the TREE_VALUE slots), by adding the hash codes
3001    of the individual types.  */
3002
3003 unsigned int
3004 type_hash_list (list)
3005      tree list;
3006 {
3007   unsigned int hashcode;
3008   register tree tail;
3009
3010   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3011     hashcode += TYPE_HASH (TREE_VALUE (tail));
3012
3013   return hashcode;
3014 }
3015
3016 /* These are the Hashtable callback functions.  */
3017
3018 /* Returns true if the types are equal.  */
3019
3020 static int
3021 type_hash_eq (va, vb)
3022      const void *va;
3023      const void *vb;
3024 {
3025   const struct type_hash *a = va, *b = vb;
3026   if (a->hash == b->hash
3027       && TREE_CODE (a->type) == TREE_CODE (b->type)
3028       && TREE_TYPE (a->type) == TREE_TYPE (b->type)
3029       && attribute_list_equal (TYPE_ATTRIBUTES (a->type),
3030                                TYPE_ATTRIBUTES (b->type))
3031       && TYPE_ALIGN (a->type) == TYPE_ALIGN (b->type)
3032       && (TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
3033           || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
3034                                  TYPE_MAX_VALUE (b->type)))
3035       && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
3036           || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
3037                                  TYPE_MIN_VALUE (b->type)))
3038       /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE.  */
3039       && (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
3040           || (TYPE_DOMAIN (a->type)
3041               && TREE_CODE (TYPE_DOMAIN (a->type)) == TREE_LIST
3042               && TYPE_DOMAIN (b->type)
3043               && TREE_CODE (TYPE_DOMAIN (b->type)) == TREE_LIST
3044               && type_list_equal (TYPE_DOMAIN (a->type),
3045                                   TYPE_DOMAIN (b->type)))))
3046     return 1;
3047   return 0;
3048 }
3049
3050 /* Return the cached hash value.  */
3051
3052 static unsigned int
3053 type_hash_hash (item)
3054      const void *item;
3055 {
3056   return ((const struct type_hash *) item)->hash;
3057 }
3058
3059 /* Look in the type hash table for a type isomorphic to TYPE.
3060    If one is found, return it.  Otherwise return 0.  */
3061
3062 tree
3063 type_hash_lookup (hashcode, type)
3064      unsigned int hashcode;
3065      tree type;
3066 {
3067   struct type_hash *h, in;
3068
3069   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
3070      must call that routine before comparing TYPE_ALIGNs.  */
3071   layout_type (type);
3072
3073   in.hash = hashcode;
3074   in.type = type;
3075
3076   h = htab_find_with_hash (type_hash_table, &in, hashcode);
3077   if (h)
3078     return h->type;
3079   return NULL_TREE;
3080 }
3081
3082 /* Add an entry to the type-hash-table
3083    for a type TYPE whose hash code is HASHCODE.  */
3084
3085 void
3086 type_hash_add (hashcode, type)
3087      unsigned int hashcode;
3088      tree type;
3089 {
3090   struct type_hash *h;
3091   void **loc;
3092
3093   h = (struct type_hash *) ggc_alloc (sizeof (struct type_hash));
3094   h->hash = hashcode;
3095   h->type = type;
3096   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
3097   *(struct type_hash **) loc = h;
3098 }
3099
3100 /* Given TYPE, and HASHCODE its hash code, return the canonical
3101    object for an identical type if one already exists.
3102    Otherwise, return TYPE, and record it as the canonical object
3103    if it is a permanent object.
3104
3105    To use this function, first create a type of the sort you want.
3106    Then compute its hash code from the fields of the type that
3107    make it different from other similar types.
3108    Then call this function and use the value.
3109    This function frees the type you pass in if it is a duplicate.  */
3110
3111 /* Set to 1 to debug without canonicalization.  Never set by program.  */
3112 int debug_no_type_hash = 0;
3113
3114 tree
3115 type_hash_canon (hashcode, type)
3116      unsigned int hashcode;
3117      tree type;
3118 {
3119   tree t1;
3120
3121   if (debug_no_type_hash)
3122     return type;
3123
3124   /* See if the type is in the hash table already.  If so, return it.
3125      Otherwise, add the type.  */
3126   t1 = type_hash_lookup (hashcode, type);
3127   if (t1 != 0)
3128     {
3129 #ifdef GATHER_STATISTICS
3130       tree_node_counts[(int) t_kind]--;
3131       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
3132 #endif
3133       return t1;
3134     }
3135   else
3136     {
3137       type_hash_add (hashcode, type);
3138       return type;
3139     }
3140 }
3141
3142 /* See if the data pointed to by the type hash table is marked.  */
3143
3144 static int
3145 type_hash_marked_p (p)
3146      const void *p;
3147 {
3148   return ggc_marked_p (((struct type_hash *) p)->type);
3149 }
3150
3151 /* Mark the entry in the type hash table the type it points to is marked. */
3152
3153 static void
3154 type_hash_mark (p)
3155      const void *p;
3156 {
3157   ggc_mark (p);
3158 }
3159
3160 /* Mark the hashtable slot pointed to by ENTRY (which is really a
3161    `tree**') for GC.  */
3162
3163 static int
3164 mark_tree_hashtable_entry (entry, data)
3165      void **entry;
3166      void *data ATTRIBUTE_UNUSED;
3167 {
3168   ggc_mark_tree ((tree) *entry);
3169   return 1;
3170 }
3171
3172 /* Mark ARG (which is really a htab_t whose slots are trees) for
3173    GC.  */
3174
3175 void
3176 mark_tree_hashtable (arg)
3177      void *arg;
3178 {
3179   htab_t t = *(htab_t *) arg;
3180   htab_traverse (t, mark_tree_hashtable_entry, 0);
3181 }
3182
3183 static void
3184 print_type_hash_statistics ()
3185 {
3186   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
3187            (long) htab_size (type_hash_table),
3188            (long) htab_elements (type_hash_table),
3189            htab_collisions (type_hash_table));
3190 }
3191
3192 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3193    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3194    by adding the hash codes of the individual attributes.  */
3195
3196 unsigned int
3197 attribute_hash_list (list)
3198      tree list;
3199 {
3200   unsigned int hashcode;
3201   register tree tail;
3202
3203   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3204     /* ??? Do we want to add in TREE_VALUE too? */
3205     hashcode += TYPE_HASH (TREE_PURPOSE (tail));
3206   return hashcode;
3207 }
3208
3209 /* Given two lists of attributes, return true if list l2 is
3210    equivalent to l1.  */
3211
3212 int
3213 attribute_list_equal (l1, l2)
3214      tree l1, l2;
3215 {
3216    return attribute_list_contained (l1, l2)
3217           && attribute_list_contained (l2, l1);
3218 }
3219
3220 /* Given two lists of attributes, return true if list L2 is
3221    completely contained within L1.  */
3222 /* ??? This would be faster if attribute names were stored in a canonicalized
3223    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3224    must be used to show these elements are equivalent (which they are).  */
3225 /* ??? It's not clear that attributes with arguments will always be handled
3226    correctly.  */
3227
3228 int
3229 attribute_list_contained (l1, l2)
3230      tree l1, l2;
3231 {
3232   register tree t1, t2;
3233
3234   /* First check the obvious, maybe the lists are identical.  */
3235   if (l1 == l2)
3236     return 1;
3237
3238   /* Maybe the lists are similar.  */
3239   for (t1 = l1, t2 = l2;
3240        t1 != 0 && t2 != 0
3241         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
3242         && TREE_VALUE (t1) == TREE_VALUE (t2);
3243        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
3244
3245   /* Maybe the lists are equal.  */
3246   if (t1 == 0 && t2 == 0)
3247      return 1;
3248
3249   for (; t2 != 0; t2 = TREE_CHAIN (t2))
3250     {
3251       tree attr;
3252       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
3253            attr != NULL_TREE;
3254            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
3255                                     TREE_CHAIN (attr)))
3256         {
3257           if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
3258             break;
3259         }
3260
3261       if (attr == 0)
3262         return 0;
3263
3264       if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
3265         return 0;
3266     }
3267
3268   return 1;
3269 }
3270
3271 /* Given two lists of types
3272    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3273    return 1 if the lists contain the same types in the same order.
3274    Also, the TREE_PURPOSEs must match.  */
3275
3276 int
3277 type_list_equal (l1, l2)
3278      tree l1, l2;
3279 {
3280   register tree t1, t2;
3281
3282   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3283     if (TREE_VALUE (t1) != TREE_VALUE (t2)
3284         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
3285             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
3286                   && (TREE_TYPE (TREE_PURPOSE (t1))
3287                       == TREE_TYPE (TREE_PURPOSE (t2))))))
3288       return 0;
3289
3290   return t1 == t2;
3291 }
3292
3293 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
3294    given by TYPE.  If the argument list accepts variable arguments,
3295    then this function counts only the ordinary arguments.  */
3296
3297 int
3298 type_num_arguments (type)
3299      tree type;
3300 {
3301   int i = 0;
3302   tree t;
3303
3304   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
3305     /* If the function does not take a variable number of arguments,
3306        the last element in the list will have type `void'.  */
3307     if (VOID_TYPE_P (TREE_VALUE (t)))
3308       break;
3309     else
3310       ++i;
3311
3312   return i;
3313 }
3314
3315 /* Nonzero if integer constants T1 and T2
3316    represent the same constant value.  */
3317
3318 int
3319 tree_int_cst_equal (t1, t2)
3320      tree t1, t2;
3321 {
3322   if (t1 == t2)
3323     return 1;
3324
3325   if (t1 == 0 || t2 == 0)
3326     return 0;
3327
3328   if (TREE_CODE (t1) == INTEGER_CST
3329       && TREE_CODE (t2) == INTEGER_CST
3330       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3331       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
3332     return 1;
3333
3334   return 0;
3335 }
3336
3337 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3338    The precise way of comparison depends on their data type.  */
3339
3340 int
3341 tree_int_cst_lt (t1, t2)
3342      tree t1, t2;
3343 {
3344   if (t1 == t2)
3345     return 0;
3346
3347   if (! TREE_UNSIGNED (TREE_TYPE (t1)))
3348     return INT_CST_LT (t1, t2);
3349
3350   return INT_CST_LT_UNSIGNED (t1, t2);
3351 }
3352
3353 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
3354
3355 int
3356 tree_int_cst_compare (t1, t2)
3357      tree t1;
3358      tree t2;
3359 {
3360   if (tree_int_cst_lt (t1, t2))
3361     return -1;
3362   else if (tree_int_cst_lt (t2, t1))
3363     return 1;
3364   else
3365     return 0;
3366 }
3367
3368 /* Return 1 if T is an INTEGER_CST that can be represented in a single
3369    HOST_WIDE_INT value.  If POS is nonzero, the result must be positive.  */
3370
3371 int
3372 host_integerp (t, pos)
3373      tree t;
3374      int pos;
3375 {
3376   return (TREE_CODE (t) == INTEGER_CST
3377           && ! TREE_OVERFLOW (t)
3378           && ((TREE_INT_CST_HIGH (t) == 0
3379                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
3380               || (! pos && TREE_INT_CST_HIGH (t) == -1
3381                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
3382               || (! pos && TREE_INT_CST_HIGH (t) == 0
3383                   && TREE_UNSIGNED (TREE_TYPE (t)))));
3384 }
3385
3386 /* Return the HOST_WIDE_INT least significant bits of T if it is an
3387    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
3388    be positive.  Abort if we cannot satisfy the above conditions.  */
3389
3390 HOST_WIDE_INT
3391 tree_low_cst (t, pos)
3392      tree t;
3393      int pos;
3394 {
3395   if (host_integerp (t, pos))
3396     return TREE_INT_CST_LOW (t);
3397   else
3398     abort ();
3399 }
3400
3401 /* Return the most significant bit of the integer constant T.  */
3402
3403 int
3404 tree_int_cst_msb (t)
3405      tree t;
3406 {
3407   register int prec;
3408   HOST_WIDE_INT h;
3409   unsigned HOST_WIDE_INT l;
3410
3411   /* Note that using TYPE_PRECISION here is wrong.  We care about the
3412      actual bits, not the (arbitrary) range of the type.  */
3413   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
3414   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
3415                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
3416   return (l & 1) == 1;
3417 }
3418
3419 /* Return an indication of the sign of the integer constant T.
3420    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3421    Note that -1 will never be returned it T's type is unsigned.  */
3422
3423 int
3424 tree_int_cst_sgn (t)
3425      tree t;
3426 {
3427   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3428     return 0;
3429   else if (TREE_UNSIGNED (TREE_TYPE (t)))
3430     return 1;
3431   else if (TREE_INT_CST_HIGH (t) < 0)
3432     return -1;
3433   else
3434     return 1;
3435 }
3436
3437 /* Compare two constructor-element-type constants.  Return 1 if the lists
3438    are known to be equal; otherwise return 0.  */
3439
3440 int
3441 simple_cst_list_equal (l1, l2)
3442      tree l1, l2;
3443 {
3444   while (l1 != NULL_TREE && l2 != NULL_TREE)
3445     {
3446       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3447         return 0;
3448
3449       l1 = TREE_CHAIN (l1);
3450       l2 = TREE_CHAIN (l2);
3451     }
3452
3453   return l1 == l2;
3454 }
3455
3456 /* Return truthvalue of whether T1 is the same tree structure as T2.
3457    Return 1 if they are the same.
3458    Return 0 if they are understandably different.
3459    Return -1 if either contains tree structure not understood by
3460    this function.  */
3461
3462 int
3463 simple_cst_equal (t1, t2)
3464      tree t1, t2;
3465 {
3466   register enum tree_code code1, code2;
3467   int cmp;
3468   int i;
3469
3470   if (t1 == t2)
3471     return 1;
3472   if (t1 == 0 || t2 == 0)
3473     return 0;
3474
3475   code1 = TREE_CODE (t1);
3476   code2 = TREE_CODE (t2);
3477
3478   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
3479     {
3480       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3481           || code2 == NON_LVALUE_EXPR)
3482         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3483       else
3484         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
3485     }
3486
3487   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3488            || code2 == NON_LVALUE_EXPR)
3489     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
3490
3491   if (code1 != code2)
3492     return 0;
3493
3494   switch (code1)
3495     {
3496     case INTEGER_CST:
3497       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3498               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
3499
3500     case REAL_CST:
3501       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3502
3503     case STRING_CST:
3504       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3505               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3506                          TREE_STRING_LENGTH (t1)));
3507
3508     case CONSTRUCTOR:
3509       if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
3510         return 1;
3511       else
3512         abort ();
3513
3514     case SAVE_EXPR:
3515       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3516
3517     case CALL_EXPR:
3518       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3519       if (cmp <= 0)
3520         return cmp;
3521       return
3522         simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3523
3524     case TARGET_EXPR:
3525       /* Special case: if either target is an unallocated VAR_DECL,
3526          it means that it's going to be unified with whatever the
3527          TARGET_EXPR is really supposed to initialize, so treat it
3528          as being equivalent to anything.  */
3529       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
3530            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
3531            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
3532           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
3533               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
3534               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
3535         cmp = 1;
3536       else
3537         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3538
3539       if (cmp <= 0)
3540         return cmp;
3541
3542       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3543
3544     case WITH_CLEANUP_EXPR:
3545       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3546       if (cmp <= 0)
3547         return cmp;
3548
3549       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
3550
3551     case COMPONENT_REF:
3552       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
3553         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3554
3555       return 0;
3556
3557     case VAR_DECL:
3558     case PARM_DECL:
3559     case CONST_DECL:
3560     case FUNCTION_DECL:
3561       return 0;
3562
3563     default:
3564       break;
3565     }
3566
3567   /* This general rule works for most tree codes.  All exceptions should be
3568      handled above.  If this is a language-specific tree code, we can't
3569      trust what might be in the operand, so say we don't know
3570      the situation.  */
3571   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
3572     return -1;
3573
3574   switch (TREE_CODE_CLASS (code1))
3575     {
3576     case '1':
3577     case '2':
3578     case '<':
3579     case 'e':
3580     case 'r':
3581     case 's':
3582       cmp = 1;
3583       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
3584         {
3585           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
3586           if (cmp <= 0)
3587             return cmp;
3588         }
3589
3590       return cmp;
3591
3592     default:
3593       return -1;
3594     }
3595 }
3596
3597 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
3598    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
3599    than U, respectively.  */
3600
3601 int
3602 compare_tree_int (t, u)
3603      tree t;
3604      unsigned int u;
3605 {
3606   if (tree_int_cst_sgn (t) < 0)
3607     return -1;
3608   else if (TREE_INT_CST_HIGH (t) != 0)
3609     return 1;
3610   else if (TREE_INT_CST_LOW (t) == u)
3611     return 0;
3612   else if (TREE_INT_CST_LOW (t) < u)
3613     return -1;
3614   else
3615     return 1;
3616 }
3617 \f
3618 /* Constructors for pointer, array and function types.
3619    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
3620    constructed by language-dependent code, not here.)  */
3621
3622 /* Construct, lay out and return the type of pointers to TO_TYPE.
3623    If such a type has already been constructed, reuse it.  */
3624
3625 tree
3626 build_pointer_type (to_type)
3627      tree to_type;
3628 {
3629   register tree t = TYPE_POINTER_TO (to_type);
3630
3631   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
3632
3633   if (t != 0)
3634     return t;
3635
3636   /* We need a new one.  */
3637   t = make_node (POINTER_TYPE);
3638
3639   TREE_TYPE (t) = to_type;
3640
3641   /* Record this type as the pointer to TO_TYPE.  */
3642   TYPE_POINTER_TO (to_type) = t;
3643
3644   /* Lay out the type.  This function has many callers that are concerned
3645      with expression-construction, and this simplifies them all.
3646      Also, it guarantees the TYPE_SIZE is in the same obstack as the type.  */
3647   layout_type (t);
3648
3649   return t;
3650 }
3651
3652 /* Build the node for the type of references-to-TO_TYPE.  */
3653
3654 tree
3655 build_reference_type (to_type)
3656      tree to_type;
3657 {
3658   register tree t = TYPE_REFERENCE_TO (to_type);
3659
3660   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
3661
3662   if (t)
3663     return t;
3664
3665   /* We need a new one.  */
3666   t = make_node (REFERENCE_TYPE);
3667
3668   TREE_TYPE (t) = to_type;
3669
3670   /* Record this type as the pointer to TO_TYPE.  */
3671   TYPE_REFERENCE_TO (to_type) = t;
3672
3673   layout_type (t);
3674
3675   return t;
3676 }
3677
3678 /* Build a type that is compatible with t but has no cv quals anywhere
3679    in its type, thus
3680
3681    const char *const *const *  ->  char ***.  */
3682
3683 tree
3684 build_type_no_quals (t)
3685   tree t;
3686 {
3687   switch (TREE_CODE (t))
3688     {
3689     case POINTER_TYPE:
3690       return build_pointer_type (build_type_no_quals (TREE_TYPE (t)));
3691     case REFERENCE_TYPE:
3692       return build_reference_type (build_type_no_quals (TREE_TYPE (t)));
3693     default:
3694       return TYPE_MAIN_VARIANT (t);
3695     }
3696 }
3697
3698 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
3699    MAXVAL should be the maximum value in the domain
3700    (one less than the length of the array).
3701
3702    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
3703    We don't enforce this limit, that is up to caller (e.g. language front end).
3704    The limit exists because the result is a signed type and we don't handle
3705    sizes that use more than one HOST_WIDE_INT.  */
3706
3707 tree
3708 build_index_type (maxval)
3709      tree maxval;
3710 {
3711   register tree itype = make_node (INTEGER_TYPE);
3712
3713   TREE_TYPE (itype) = sizetype;
3714   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
3715   TYPE_MIN_VALUE (itype) = size_zero_node;
3716   TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
3717   TYPE_MODE (itype) = TYPE_MODE (sizetype);
3718   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
3719   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
3720   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
3721   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
3722
3723   if (host_integerp (maxval, 1))
3724     return type_hash_canon (tree_low_cst (maxval, 1), itype);
3725   else
3726     return itype;
3727 }
3728
3729 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
3730    ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
3731    low bound LOWVAL and high bound HIGHVAL.
3732    if TYPE==NULL_TREE, sizetype is used.  */
3733
3734 tree
3735 build_range_type (type, lowval, highval)
3736      tree type, lowval, highval;
3737 {
3738   register tree itype = make_node (INTEGER_TYPE);
3739
3740   TREE_TYPE (itype) = type;
3741   if (type == NULL_TREE)
3742     type = sizetype;
3743
3744   TYPE_MIN_VALUE (itype) = convert (type, lowval);
3745   TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
3746
3747   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
3748   TYPE_MODE (itype) = TYPE_MODE (type);
3749   TYPE_SIZE (itype) = TYPE_SIZE (type);
3750   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
3751   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
3752   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
3753
3754   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
3755     return type_hash_canon (tree_low_cst (highval, 0)
3756                             - tree_low_cst (lowval, 0),
3757                             itype);
3758   else
3759     return itype;
3760 }
3761
3762 /* Just like build_index_type, but takes lowval and highval instead
3763    of just highval (maxval).  */
3764
3765 tree
3766 build_index_2_type (lowval,highval)
3767      tree lowval, highval;
3768 {
3769   return build_range_type (sizetype, lowval, highval);
3770 }
3771
3772 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
3773    Needed because when index types are not hashed, equal index types
3774    built at different times appear distinct, even though structurally,
3775    they are not.  */
3776
3777 int
3778 index_type_equal (itype1, itype2)
3779      tree itype1, itype2;
3780 {
3781   if (TREE_CODE (itype1) != TREE_CODE (itype2))
3782     return 0;
3783
3784   if (TREE_CODE (itype1) == INTEGER_TYPE)
3785     {
3786       if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
3787           || TYPE_MODE (itype1) != TYPE_MODE (itype2)
3788           || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1
3789           || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
3790         return 0;
3791
3792       if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1),
3793                                  TYPE_MIN_VALUE (itype2))
3794           && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1),
3795                                     TYPE_MAX_VALUE (itype2)))
3796         return 1;
3797     }
3798
3799   return 0;
3800 }
3801
3802 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
3803    and number of elements specified by the range of values of INDEX_TYPE.
3804    If such a type has already been constructed, reuse it.  */
3805
3806 tree
3807 build_array_type (elt_type, index_type)
3808      tree elt_type, index_type;
3809 {
3810   register tree t;
3811   unsigned int hashcode;
3812
3813   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
3814     {
3815       error ("arrays of functions are not meaningful");
3816       elt_type = integer_type_node;
3817     }
3818
3819   /* Make sure TYPE_POINTER_TO (elt_type) is filled in.  */
3820   build_pointer_type (elt_type);
3821
3822   /* Allocate the array after the pointer type,
3823      in case we free it in type_hash_canon.  */
3824   t = make_node (ARRAY_TYPE);
3825   TREE_TYPE (t) = elt_type;
3826   TYPE_DOMAIN (t) = index_type;
3827
3828   if (index_type == 0)
3829     {
3830       return t;
3831     }
3832
3833   hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
3834   t = type_hash_canon (hashcode, t);
3835
3836   if (!COMPLETE_TYPE_P (t))
3837     layout_type (t);
3838   return t;
3839 }
3840
3841 /* Return the TYPE of the elements comprising
3842    the innermost dimension of ARRAY.  */
3843
3844 tree
3845 get_inner_array_type (array)
3846     tree array;
3847 {
3848   tree type = TREE_TYPE (array);
3849
3850   while (TREE_CODE (type) == ARRAY_TYPE)
3851     type = TREE_TYPE (type);
3852
3853   return type;
3854 }
3855
3856 /* Construct, lay out and return
3857    the type of functions returning type VALUE_TYPE
3858    given arguments of types ARG_TYPES.
3859    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
3860    are data type nodes for the arguments of the function.
3861    If such a type has already been constructed, reuse it.  */
3862
3863 tree
3864 build_function_type (value_type, arg_types)
3865      tree value_type, arg_types;
3866 {
3867   register tree t;
3868   unsigned int hashcode;
3869
3870   if (TREE_CODE (value_type) == FUNCTION_TYPE)
3871     {
3872       error ("function return type cannot be function");
3873       value_type = integer_type_node;
3874     }
3875
3876   /* Make a node of the sort we want.  */
3877   t = make_node (FUNCTION_TYPE);
3878   TREE_TYPE (t) = value_type;
3879   TYPE_ARG_TYPES (t) = arg_types;
3880
3881   /* If we already have such a type, use the old one and free this one.  */
3882   hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
3883   t = type_hash_canon (hashcode, t);
3884
3885   if (!COMPLETE_TYPE_P (t))
3886     layout_type (t);
3887   return t;
3888 }
3889
3890 /* Construct, lay out and return the type of methods belonging to class
3891    BASETYPE and whose arguments and values are described by TYPE.
3892    If that type exists already, reuse it.
3893    TYPE must be a FUNCTION_TYPE node.  */
3894
3895 tree
3896 build_method_type (basetype, type)
3897      tree basetype, type;
3898 {
3899   register tree t;
3900   unsigned int hashcode;
3901
3902   /* Make a node of the sort we want.  */
3903   t = make_node (METHOD_TYPE);
3904
3905   if (TREE_CODE (type) != FUNCTION_TYPE)
3906     abort ();
3907
3908   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3909   TREE_TYPE (t) = TREE_TYPE (type);
3910
3911   /* The actual arglist for this function includes a "hidden" argument
3912      which is "this".  Put it into the list of argument types.  */
3913
3914   TYPE_ARG_TYPES (t)
3915     = tree_cons (NULL_TREE,
3916                  build_pointer_type (basetype), TYPE_ARG_TYPES (type));
3917
3918   /* If we already have such a type, use the old one and free this one.  */
3919   hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3920   t = type_hash_canon (hashcode, t);
3921
3922   if (!COMPLETE_TYPE_P (t))
3923     layout_type (t);
3924
3925   return t;
3926 }
3927
3928 /* Construct, lay out and return the type of offsets to a value
3929    of type TYPE, within an object of type BASETYPE.
3930    If a suitable offset type exists already, reuse it.  */
3931
3932 tree
3933 build_offset_type (basetype, type)
3934      tree basetype, type;
3935 {
3936   register tree t;
3937   unsigned int hashcode;
3938
3939   /* Make a node of the sort we want.  */
3940   t = make_node (OFFSET_TYPE);
3941
3942   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3943   TREE_TYPE (t) = type;
3944
3945   /* If we already have such a type, use the old one and free this one.  */
3946   hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3947   t = type_hash_canon (hashcode, t);
3948
3949   if (!COMPLETE_TYPE_P (t))
3950     layout_type (t);
3951
3952   return t;
3953 }
3954
3955 /* Create a complex type whose components are COMPONENT_TYPE.  */
3956
3957 tree
3958 build_complex_type (component_type)
3959      tree component_type;
3960 {
3961   register tree t;
3962   unsigned int hashcode;
3963
3964   /* Make a node of the sort we want.  */
3965   t = make_node (COMPLEX_TYPE);
3966
3967   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
3968   set_type_quals (t, TYPE_QUALS (component_type));
3969
3970   /* If we already have such a type, use the old one and free this one.  */
3971   hashcode = TYPE_HASH (component_type);
3972   t = type_hash_canon (hashcode, t);
3973
3974   if (!COMPLETE_TYPE_P (t))
3975     layout_type (t);
3976
3977   /* If we are writing Dwarf2 output we need to create a name,
3978      since complex is a fundamental type.  */
3979   if (write_symbols == DWARF2_DEBUG && ! TYPE_NAME (t))
3980     {
3981       const char *name;
3982       if (component_type == char_type_node)
3983         name = "complex char";
3984       else if (component_type == signed_char_type_node)
3985         name = "complex signed char";
3986       else if (component_type == unsigned_char_type_node)
3987         name = "complex unsigned char";
3988       else if (component_type == short_integer_type_node)
3989         name = "complex short int";
3990       else if (component_type == short_unsigned_type_node)
3991         name = "complex short unsigned int";
3992       else if (component_type == integer_type_node)
3993         name = "complex int";
3994       else if (component_type == unsigned_type_node)
3995         name = "complex unsigned int";
3996       else if (component_type == long_integer_type_node)
3997         name = "complex long int";
3998       else if (component_type == long_unsigned_type_node)
3999         name = "complex long unsigned int";
4000       else if (component_type == long_long_integer_type_node)
4001         name = "complex long long int";
4002       else if (component_type == long_long_unsigned_type_node)
4003         name = "complex long long unsigned int";
4004       else
4005         name = 0;
4006
4007       if (name != 0)
4008         TYPE_NAME (t) = get_identifier (name);
4009     }
4010
4011   return t;
4012 }
4013 \f
4014 /* Return OP, stripped of any conversions to wider types as much as is safe.
4015    Converting the value back to OP's type makes a value equivalent to OP.
4016
4017    If FOR_TYPE is nonzero, we return a value which, if converted to
4018    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4019
4020    If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4021    narrowest type that can hold the value, even if they don't exactly fit.
4022    Otherwise, bit-field references are changed to a narrower type
4023    only if they can be fetched directly from memory in that type.
4024
4025    OP must have integer, real or enumeral type.  Pointers are not allowed!
4026
4027    There are some cases where the obvious value we could return
4028    would regenerate to OP if converted to OP's type,
4029    but would not extend like OP to wider types.
4030    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4031    For example, if OP is (unsigned short)(signed char)-1,
4032    we avoid returning (signed char)-1 if FOR_TYPE is int,
4033    even though extending that to an unsigned short would regenerate OP,
4034    since the result of extending (signed char)-1 to (int)
4035    is different from (int) OP.  */
4036
4037 tree
4038 get_unwidened (op, for_type)
4039      register tree op;
4040      tree for_type;
4041 {
4042   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
4043   register tree type = TREE_TYPE (op);
4044   register unsigned final_prec
4045     = TYPE_PRECISION (for_type != 0 ? for_type : type);
4046   register int uns
4047     = (for_type != 0 && for_type != type
4048        && final_prec > TYPE_PRECISION (type)
4049        && TREE_UNSIGNED (type));
4050   register tree win = op;
4051
4052   while (TREE_CODE (op) == NOP_EXPR)
4053     {
4054       register int bitschange
4055         = TYPE_PRECISION (TREE_TYPE (op))
4056           - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4057
4058       /* Truncations are many-one so cannot be removed.
4059          Unless we are later going to truncate down even farther.  */
4060       if (bitschange < 0
4061           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
4062         break;
4063
4064       /* See what's inside this conversion.  If we decide to strip it,
4065          we will set WIN.  */
4066       op = TREE_OPERAND (op, 0);
4067
4068       /* If we have not stripped any zero-extensions (uns is 0),
4069          we can strip any kind of extension.
4070          If we have previously stripped a zero-extension,
4071          only zero-extensions can safely be stripped.
4072          Any extension can be stripped if the bits it would produce
4073          are all going to be discarded later by truncating to FOR_TYPE.  */
4074
4075       if (bitschange > 0)
4076         {
4077           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
4078             win = op;
4079           /* TREE_UNSIGNED says whether this is a zero-extension.
4080              Let's avoid computing it if it does not affect WIN
4081              and if UNS will not be needed again.  */
4082           if ((uns || TREE_CODE (op) == NOP_EXPR)
4083               && TREE_UNSIGNED (TREE_TYPE (op)))
4084             {
4085               uns = 1;
4086               win = op;
4087             }
4088         }
4089     }
4090
4091   if (TREE_CODE (op) == COMPONENT_REF
4092       /* Since type_for_size always gives an integer type.  */
4093       && TREE_CODE (type) != REAL_TYPE
4094       /* Don't crash if field not laid out yet.  */
4095       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
4096       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
4097     {
4098       unsigned int innerprec
4099         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4100
4101       type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
4102
4103       /* We can get this structure field in the narrowest type it fits in.
4104          If FOR_TYPE is 0, do this only for a field that matches the
4105          narrower type exactly and is aligned for it
4106          The resulting extension to its nominal type (a fullword type)
4107          must fit the same conditions as for other extensions.  */
4108
4109       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4110           && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
4111           && (! uns || final_prec <= innerprec
4112               || TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4113           && type != 0)
4114         {
4115           win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4116                        TREE_OPERAND (op, 1));
4117           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4118           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4119         }
4120     }
4121
4122   return win;
4123 }
4124 \f
4125 /* Return OP or a simpler expression for a narrower value
4126    which can be sign-extended or zero-extended to give back OP.
4127    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4128    or 0 if the value should be sign-extended.  */
4129
4130 tree
4131 get_narrower (op, unsignedp_ptr)
4132      register tree op;
4133      int *unsignedp_ptr;
4134 {
4135   register int uns = 0;
4136   int first = 1;
4137   register tree win = op;
4138
4139   while (TREE_CODE (op) == NOP_EXPR)
4140     {
4141       register int bitschange
4142         = (TYPE_PRECISION (TREE_TYPE (op))
4143            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
4144
4145       /* Truncations are many-one so cannot be removed.  */
4146       if (bitschange < 0)
4147         break;
4148
4149       /* See what's inside this conversion.  If we decide to strip it,
4150          we will set WIN.  */
4151       op = TREE_OPERAND (op, 0);
4152
4153       if (bitschange > 0)
4154         {
4155           /* An extension: the outermost one can be stripped,
4156              but remember whether it is zero or sign extension.  */
4157           if (first)
4158             uns = TREE_UNSIGNED (TREE_TYPE (op));
4159           /* Otherwise, if a sign extension has been stripped,
4160              only sign extensions can now be stripped;
4161              if a zero extension has been stripped, only zero-extensions.  */
4162           else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
4163             break;
4164           first = 0;
4165         }
4166       else /* bitschange == 0 */
4167         {
4168           /* A change in nominal type can always be stripped, but we must
4169              preserve the unsignedness.  */
4170           if (first)
4171             uns = TREE_UNSIGNED (TREE_TYPE (op));
4172           first = 0;
4173         }
4174
4175       win = op;
4176     }
4177
4178   if (TREE_CODE (op) == COMPONENT_REF
4179       /* Since type_for_size always gives an integer type.  */
4180       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
4181       /* Ensure field is laid out already.  */
4182       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
4183     {
4184       unsigned HOST_WIDE_INT innerprec
4185         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4186       tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
4187
4188       /* We can get this structure field in a narrower type that fits it,
4189          but the resulting extension to its nominal type (a fullword type)
4190          must satisfy the same conditions as for other extensions.
4191
4192          Do this only for fields that are aligned (not bit-fields),
4193          because when bit-field insns will be used there is no
4194          advantage in doing this.  */
4195
4196       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4197           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
4198           && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4199           && type != 0)
4200         {
4201           if (first)
4202             uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4203           win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4204                        TREE_OPERAND (op, 1));
4205           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4206           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4207         }
4208     }
4209   *unsignedp_ptr = uns;
4210   return win;
4211 }
4212 \f
4213 /* Nonzero if integer constant C has a value that is permissible
4214    for type TYPE (an INTEGER_TYPE).  */
4215
4216 int
4217 int_fits_type_p (c, type)
4218      tree c, type;
4219 {
4220   /* If the bounds of the type are integers, we can check ourselves.
4221      Otherwise,. use force_fit_type, which checks against the precision.  */
4222   if (TYPE_MAX_VALUE (type) != NULL_TREE
4223       && TYPE_MIN_VALUE (type) != NULL_TREE
4224       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4225       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
4226     {
4227       if (TREE_UNSIGNED (type))
4228         return (! INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
4229                 && ! INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type))
4230                 /* Negative ints never fit unsigned types.  */
4231                 && ! (TREE_INT_CST_HIGH (c) < 0
4232                       && ! TREE_UNSIGNED (TREE_TYPE (c))));
4233       else
4234         return (! INT_CST_LT (TYPE_MAX_VALUE (type), c)
4235                 && ! INT_CST_LT (c, TYPE_MIN_VALUE (type))
4236                 /* Unsigned ints with top bit set never fit signed types.  */
4237                 && ! (TREE_INT_CST_HIGH (c) < 0
4238                       && TREE_UNSIGNED (TREE_TYPE (c))));
4239     }
4240   else
4241     {
4242       c = copy_node (c);
4243       TREE_TYPE (c) = type;
4244       return !force_fit_type (c, 0);
4245     }
4246 }
4247
4248 /* Given a DECL or TYPE, return the scope in which it was declared, or
4249    NULL_TREE if there is no containing scope.  */
4250
4251 tree
4252 get_containing_scope (t)
4253      tree t;
4254 {
4255   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
4256 }
4257
4258 /* Return the innermost context enclosing DECL that is
4259    a FUNCTION_DECL, or zero if none.  */
4260
4261 tree
4262 decl_function_context (decl)
4263      tree decl;
4264 {
4265   tree context;
4266
4267   if (TREE_CODE (decl) == ERROR_MARK)
4268     return 0;
4269
4270   if (TREE_CODE (decl) == SAVE_EXPR)
4271     context = SAVE_EXPR_CONTEXT (decl);
4272
4273   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
4274      where we look up the function at runtime.  Such functions always take
4275      a first argument of type 'pointer to real context'.
4276
4277      C++ should really be fixed to use DECL_CONTEXT for the real context,
4278      and use something else for the "virtual context".  */
4279   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
4280     context
4281       = TYPE_MAIN_VARIANT
4282         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4283   else
4284     context = DECL_CONTEXT (decl);
4285
4286   while (context && TREE_CODE (context) != FUNCTION_DECL)
4287     {
4288       if (TREE_CODE (context) == BLOCK)
4289         context = BLOCK_SUPERCONTEXT (context);
4290       else
4291         context = get_containing_scope (context);
4292     }
4293
4294   return context;
4295 }
4296
4297 /* Return the innermost context enclosing DECL that is
4298    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4299    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
4300
4301 tree
4302 decl_type_context (decl)
4303      tree decl;
4304 {
4305   tree context = DECL_CONTEXT (decl);
4306
4307   while (context)
4308     {
4309       if (TREE_CODE (context) == RECORD_TYPE
4310           || TREE_CODE (context) == UNION_TYPE
4311           || TREE_CODE (context) == QUAL_UNION_TYPE)
4312         return context;
4313
4314       if (TREE_CODE (context) == TYPE_DECL
4315           || TREE_CODE (context) == FUNCTION_DECL)
4316         context = DECL_CONTEXT (context);
4317
4318       else if (TREE_CODE (context) == BLOCK)
4319         context = BLOCK_SUPERCONTEXT (context);
4320
4321       else
4322         /* Unhandled CONTEXT!?  */
4323         abort ();
4324     }
4325   return NULL_TREE;
4326 }
4327
4328 /* CALL is a CALL_EXPR.  Return the declaration for the function
4329    called, or NULL_TREE if the called function cannot be
4330    determined.  */
4331
4332 tree
4333 get_callee_fndecl (call)
4334      tree call;
4335 {
4336   tree addr;
4337
4338   /* It's invalid to call this function with anything but a
4339      CALL_EXPR.  */
4340   if (TREE_CODE (call) != CALL_EXPR)
4341     abort ();
4342
4343   /* The first operand to the CALL is the address of the function
4344      called.  */
4345   addr = TREE_OPERAND (call, 0);
4346
4347   STRIP_NOPS (addr);
4348
4349   /* If this is a readonly function pointer, extract its initial value.  */
4350   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
4351       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
4352       && DECL_INITIAL (addr))
4353     addr = DECL_INITIAL (addr);
4354
4355   /* If the address is just `&f' for some function `f', then we know
4356      that `f' is being called.  */
4357   if (TREE_CODE (addr) == ADDR_EXPR
4358       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
4359     return TREE_OPERAND (addr, 0);
4360
4361   /* We couldn't figure out what was being called.  */
4362   return NULL_TREE;
4363 }
4364
4365 /* Print debugging information about the obstack O, named STR.  */
4366
4367 void
4368 print_obstack_statistics (str, o)
4369      const char *str;
4370      struct obstack *o;
4371 {
4372   struct _obstack_chunk *chunk = o->chunk;
4373   int n_chunks = 1;
4374   int n_alloc = 0;
4375
4376   n_alloc += o->next_free - chunk->contents;
4377   chunk = chunk->prev;
4378   while (chunk)
4379     {
4380       n_chunks += 1;
4381       n_alloc += chunk->limit - &chunk->contents[0];
4382       chunk = chunk->prev;
4383     }
4384   fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
4385            str, n_alloc, n_chunks);
4386 }
4387
4388 /* Print debugging information about tree nodes generated during the compile,
4389    and any language-specific information.  */
4390
4391 void
4392 dump_tree_statistics ()
4393 {
4394 #ifdef GATHER_STATISTICS
4395   int i;
4396   int total_nodes, total_bytes;
4397 #endif
4398
4399   fprintf (stderr, "\n??? tree nodes created\n\n");
4400 #ifdef GATHER_STATISTICS
4401   fprintf (stderr, "Kind                  Nodes     Bytes\n");
4402   fprintf (stderr, "-------------------------------------\n");
4403   total_nodes = total_bytes = 0;
4404   for (i = 0; i < (int) all_kinds; i++)
4405     {
4406       fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4407                tree_node_counts[i], tree_node_sizes[i]);
4408       total_nodes += tree_node_counts[i];
4409       total_bytes += tree_node_sizes[i];
4410     }
4411   fprintf (stderr, "%-20s        %9d\n", "identifier names", id_string_size);
4412   fprintf (stderr, "-------------------------------------\n");
4413   fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4414   fprintf (stderr, "-------------------------------------\n");
4415 #else
4416   fprintf (stderr, "(No per-node statistics)\n");
4417 #endif
4418   print_obstack_statistics ("permanent_obstack", &permanent_obstack);
4419   print_type_hash_statistics ();
4420   print_lang_statistics ();
4421 }
4422 \f
4423 #define FILE_FUNCTION_PREFIX_LEN 9
4424
4425 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4426
4427 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4428    clashes in cases where we can't reliably choose a unique name.
4429
4430    Derived from mkstemp.c in libiberty.  */
4431
4432 static void
4433 append_random_chars (template)
4434      char *template;
4435 {
4436   static const char letters[]
4437     = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4438   static unsigned HOST_WIDE_INT value;
4439   unsigned HOST_WIDE_INT v;
4440
4441   if (! value)
4442     {
4443       struct stat st;
4444
4445       /* VALUE should be unique for each file and must
4446          not change between compiles since this can cause
4447          bootstrap comparison errors.  */
4448
4449       if (stat (main_input_filename, &st) < 0)
4450         abort ();
4451
4452       value = st.st_dev ^ st.st_ino ^ st.st_mtime;
4453     }
4454
4455   template += strlen (template);
4456
4457   v = value;
4458
4459   /* Fill in the random bits.  */
4460   template[0] = letters[v % 62];
4461   v /= 62;
4462   template[1] = letters[v % 62];
4463   v /= 62;
4464   template[2] = letters[v % 62];
4465   v /= 62;
4466   template[3] = letters[v % 62];
4467   v /= 62;
4468   template[4] = letters[v % 62];
4469   v /= 62;
4470   template[5] = letters[v % 62];
4471
4472   template[6] = '\0';
4473 }
4474
4475 /* P is a string that will be used in a symbol.  Mask out any characters
4476    that are not valid in that context.  */
4477
4478 void
4479 clean_symbol_name (p)
4480      char *p;
4481 {
4482   for (; *p; p++)
4483     if (! (ISDIGIT(*p)
4484 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
4485             || *p == '$'
4486 #endif
4487 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
4488             || *p == '.'
4489 #endif
4490             || ISUPPER (*p)
4491             || ISLOWER (*p)))
4492       *p = '_';
4493 }
4494
4495 /* Generate a name for a function unique to this translation unit.
4496    TYPE is some string to identify the purpose of this function to the
4497    linker or collect2.  */
4498
4499 tree
4500 get_file_function_name_long (type)
4501      const char *type;
4502 {
4503   char *buf;
4504   const char *p;
4505   char *q;
4506
4507   if (first_global_object_name)
4508     p = first_global_object_name;
4509   else
4510     {
4511       /* We don't have anything that we know to be unique to this translation
4512          unit, so use what we do have and throw in some randomness.  */
4513
4514       const char *name = weak_global_object_name;
4515       const char *file = main_input_filename;
4516
4517       if (! name)
4518         name = "";
4519       if (! file)
4520         file = input_filename;
4521
4522       q = (char *) alloca (7 + strlen (name) + strlen (file));
4523
4524       sprintf (q, "%s%s", name, file);
4525       append_random_chars (q);
4526       p = q;
4527     }
4528
4529   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4530                          + strlen (type));
4531
4532   /* Set up the name of the file-level functions we may need.
4533      Use a global object (which is already required to be unique over
4534      the program) rather than the file name (which imposes extra
4535      constraints).  */
4536   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4537
4538   /* Don't need to pull weird characters out of global names.  */
4539   if (p != first_global_object_name)
4540     clean_symbol_name (buf + 11);
4541
4542   return get_identifier (buf);
4543 }
4544
4545 /* If KIND=='I', return a suitable global initializer (constructor) name.
4546    If KIND=='D', return a suitable global clean-up (destructor) name.  */
4547
4548 tree
4549 get_file_function_name (kind)
4550      int kind;
4551 {
4552   char p[2];
4553
4554   p[0] = kind;
4555   p[1] = 0;
4556
4557   return get_file_function_name_long (p);
4558 }
4559 \f
4560 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4561    The result is placed in BUFFER (which has length BIT_SIZE),
4562    with one bit in each char ('\000' or '\001').
4563
4564    If the constructor is constant, NULL_TREE is returned.
4565    Otherwise, a TREE_LIST of the non-constant elements is emitted.  */
4566
4567 tree
4568 get_set_constructor_bits (init, buffer, bit_size)
4569      tree init;
4570      char *buffer;
4571      int bit_size;
4572 {
4573   int i;
4574   tree vals;
4575   HOST_WIDE_INT domain_min
4576     = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))), 0);
4577   tree non_const_bits = NULL_TREE;
4578
4579   for (i = 0; i < bit_size; i++)
4580     buffer[i] = 0;
4581
4582   for (vals = TREE_OPERAND (init, 1);
4583        vals != NULL_TREE; vals = TREE_CHAIN (vals))
4584     {
4585       if (!host_integerp (TREE_VALUE (vals), 0)
4586           || (TREE_PURPOSE (vals) != NULL_TREE
4587               && !host_integerp (TREE_PURPOSE (vals), 0)))
4588         non_const_bits
4589           = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
4590       else if (TREE_PURPOSE (vals) != NULL_TREE)
4591         {
4592           /* Set a range of bits to ones.  */
4593           HOST_WIDE_INT lo_index
4594             = tree_low_cst (TREE_PURPOSE (vals), 0) - domain_min;
4595           HOST_WIDE_INT hi_index
4596             = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4597
4598           if (lo_index < 0 || lo_index >= bit_size
4599               || hi_index < 0 || hi_index >= bit_size)
4600             abort ();
4601           for (; lo_index <= hi_index; lo_index++)
4602             buffer[lo_index] = 1;
4603         }
4604       else
4605         {
4606           /* Set a single bit to one.  */
4607           HOST_WIDE_INT index
4608             = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4609           if (index < 0 || index >= bit_size)
4610             {
4611               error ("invalid initializer for bit string");
4612               return NULL_TREE;
4613             }
4614           buffer[index] = 1;
4615         }
4616     }
4617   return non_const_bits;
4618 }
4619
4620 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4621    The result is placed in BUFFER (which is an array of bytes).
4622    If the constructor is constant, NULL_TREE is returned.
4623    Otherwise, a TREE_LIST of the non-constant elements is emitted.  */
4624
4625 tree
4626 get_set_constructor_bytes (init, buffer, wd_size)
4627      tree init;
4628      unsigned char *buffer;
4629      int wd_size;
4630 {
4631   int i;
4632   int set_word_size = BITS_PER_UNIT;
4633   int bit_size = wd_size * set_word_size;
4634   int bit_pos = 0;
4635   unsigned char *bytep = buffer;
4636   char *bit_buffer = (char *) alloca (bit_size);
4637   tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
4638
4639   for (i = 0; i < wd_size; i++)
4640     buffer[i] = 0;
4641
4642   for (i = 0; i < bit_size; i++)
4643     {
4644       if (bit_buffer[i])
4645         {
4646           if (BYTES_BIG_ENDIAN)
4647             *bytep |= (1 << (set_word_size - 1 - bit_pos));
4648           else
4649             *bytep |= 1 << bit_pos;
4650         }
4651       bit_pos++;
4652       if (bit_pos >= set_word_size)
4653         bit_pos = 0, bytep++;
4654     }
4655   return non_const_bits;
4656 }
4657 \f
4658 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4659 /* Complain that the tree code of NODE does not match the expected CODE.
4660    FILE, LINE, and FUNCTION are of the caller.  */
4661
4662 void
4663 tree_check_failed (node, code, file, line, function)
4664      const tree node;
4665      enum tree_code code;
4666      const char *file;
4667      int line;
4668      const char *function;
4669 {
4670   internal_error ("Tree check: expected %s, have %s in %s, at %s:%d",
4671                   tree_code_name[code], tree_code_name[TREE_CODE (node)],
4672                   function, trim_filename (file), line);
4673 }
4674
4675 /* Similar to above, except that we check for a class of tree
4676    code, given in CL.  */
4677
4678 void
4679 tree_class_check_failed (node, cl, file, line, function)
4680      const tree node;
4681      int cl;
4682      const char *file;
4683      int line;
4684      const char *function;
4685 {
4686   internal_error
4687     ("Tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
4688      cl, TREE_CODE_CLASS (TREE_CODE (node)),
4689      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
4690 }
4691
4692 #endif /* ENABLE_TREE_CHECKING */
4693 \f
4694 /* For a new vector type node T, build the information necessary for
4695    debuggint output.  */
4696
4697 static void
4698 finish_vector_type (t)
4699      tree t;
4700 {
4701   layout_type (t);
4702
4703   {
4704     tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
4705     tree array = build_array_type (TREE_TYPE (t),
4706                                    build_index_type (index));
4707     tree rt = make_node (RECORD_TYPE);
4708
4709     TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
4710     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
4711     layout_type (rt);
4712     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
4713     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
4714        the representation type, and we want to find that die when looking up
4715        the vector type.  This is most easily achieved by making the TYPE_UID
4716        numbers equal.  */
4717     TYPE_UID (rt) = TYPE_UID (t);
4718   }
4719 }
4720
4721 /* Create nodes for all integer types (and error_mark_node) using the sizes
4722    of C datatypes.  The caller should call set_sizetype soon after calling
4723    this function to select one of the types as sizetype.  */
4724
4725 void
4726 build_common_tree_nodes (signed_char)
4727      int signed_char;
4728 {
4729   error_mark_node = make_node (ERROR_MARK);
4730   TREE_TYPE (error_mark_node) = error_mark_node;
4731
4732   initialize_sizetypes ();
4733
4734   /* Define both `signed char' and `unsigned char'.  */
4735   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4736   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4737
4738   /* Define `char', which is like either `signed char' or `unsigned char'
4739      but not the same as either.  */
4740   char_type_node
4741     = (signed_char
4742        ? make_signed_type (CHAR_TYPE_SIZE)
4743        : make_unsigned_type (CHAR_TYPE_SIZE));
4744
4745   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4746   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4747   integer_type_node = make_signed_type (INT_TYPE_SIZE);
4748   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4749   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4750   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4751   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4752   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4753
4754   intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
4755   intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
4756   intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
4757   intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
4758   intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
4759
4760   unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
4761   unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
4762   unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
4763   unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
4764   unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
4765 }
4766
4767 /* Call this function after calling build_common_tree_nodes and set_sizetype.
4768    It will create several other common tree nodes.  */
4769
4770 void
4771 build_common_tree_nodes_2 (short_double)
4772      int short_double;
4773 {
4774   /* Define these next since types below may used them.  */
4775   integer_zero_node = build_int_2 (0, 0);
4776   integer_one_node = build_int_2 (1, 0);
4777   integer_minus_one_node = build_int_2 (-1, -1);
4778
4779   size_zero_node = size_int (0);
4780   size_one_node = size_int (1);
4781   bitsize_zero_node = bitsize_int (0);
4782   bitsize_one_node = bitsize_int (1);
4783   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
4784
4785   void_type_node = make_node (VOID_TYPE);
4786   layout_type (void_type_node);
4787
4788   /* We are not going to have real types in C with less than byte alignment,
4789      so we might as well not have any types that claim to have it.  */
4790   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
4791   TYPE_USER_ALIGN (void_type_node) = 0;
4792
4793   null_pointer_node = build_int_2 (0, 0);
4794   TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4795   layout_type (TREE_TYPE (null_pointer_node));
4796
4797   ptr_type_node = build_pointer_type (void_type_node);
4798   const_ptr_type_node
4799     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
4800
4801   float_type_node = make_node (REAL_TYPE);
4802   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4803   layout_type (float_type_node);
4804
4805   double_type_node = make_node (REAL_TYPE);
4806   if (short_double)
4807     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4808   else
4809     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4810   layout_type (double_type_node);
4811
4812   long_double_type_node = make_node (REAL_TYPE);
4813   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4814   layout_type (long_double_type_node);
4815
4816   complex_integer_type_node = make_node (COMPLEX_TYPE);
4817   TREE_TYPE (complex_integer_type_node) = integer_type_node;
4818   layout_type (complex_integer_type_node);
4819
4820   complex_float_type_node = make_node (COMPLEX_TYPE);
4821   TREE_TYPE (complex_float_type_node) = float_type_node;
4822   layout_type (complex_float_type_node);
4823
4824   complex_double_type_node = make_node (COMPLEX_TYPE);
4825   TREE_TYPE (complex_double_type_node) = double_type_node;
4826   layout_type (complex_double_type_node);
4827
4828   complex_long_double_type_node = make_node (COMPLEX_TYPE);
4829   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
4830   layout_type (complex_long_double_type_node);
4831
4832   {
4833     tree t;
4834     BUILD_VA_LIST_TYPE (t);
4835
4836     /* Many back-ends define record types without seting TYPE_NAME.
4837        If we copied the record type here, we'd keep the original
4838        record type without a name.  This breaks name mangling.  So,
4839        don't copy record types and let c_common_nodes_and_builtins()
4840        declare the type to be __builtin_va_list.  */
4841     if (TREE_CODE (t) != RECORD_TYPE)
4842       t = build_type_copy (t);
4843
4844     va_list_type_node = t;
4845   }
4846
4847   V4SF_type_node = make_node (VECTOR_TYPE);
4848   TREE_TYPE (V4SF_type_node) = float_type_node;
4849   TYPE_MODE (V4SF_type_node) = V4SFmode;
4850   finish_vector_type (V4SF_type_node);
4851
4852   V4SI_type_node = make_node (VECTOR_TYPE);
4853   TREE_TYPE (V4SI_type_node) = intSI_type_node;
4854   TYPE_MODE (V4SI_type_node) = V4SImode;
4855   finish_vector_type (V4SI_type_node);
4856
4857   V2SI_type_node = make_node (VECTOR_TYPE);
4858   TREE_TYPE (V2SI_type_node) = intSI_type_node;
4859   TYPE_MODE (V2SI_type_node) = V2SImode;
4860   finish_vector_type (V2SI_type_node);
4861
4862   V4HI_type_node = make_node (VECTOR_TYPE);
4863   TREE_TYPE (V4HI_type_node) = intHI_type_node;
4864   TYPE_MODE (V4HI_type_node) = V4HImode;
4865   finish_vector_type (V4HI_type_node);
4866
4867   V8QI_type_node = make_node (VECTOR_TYPE);
4868   TREE_TYPE (V8QI_type_node) = intQI_type_node;
4869   TYPE_MODE (V8QI_type_node) = V8QImode;
4870   finish_vector_type (V8QI_type_node);
4871 }