gcc/tree.c

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