gcc/tree.c

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