gcc/c-typeck.c

   1 /* Build expressions with type checking for C compiler.
   2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002, 2003, 2004 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
  23 /* This file is part of the C front end.
  24    It contains routines to build C expressions given their operands,
  25    including computing the types of the result, C-specific error checks,
  26    and some optimization.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "rtl.h"
  33 #include "tree.h"
  34 #include "langhooks.h"
  35 #include "c-tree.h"
  36 #include "tm_p.h"
  37 #include "flags.h"
  38 #include "output.h"
  39 #include "expr.h"
  40 #include "toplev.h"
  41 #include "intl.h"
  42 #include "ggc.h"
  43 #include "target.h"
  44 #include "tree-iterator.h"
  45 #include "tree-gimple.h"
  46
  47
  48 /* Nonzero if we've already printed a "missing braces around initializer"
  49    message within this initializer.  */
  50 static int missing_braces_mentioned;
  51
  52 static int require_constant_value;
  53 static int require_constant_elements;
  54
  55 static tree qualify_type (tree, tree);
  56 static int tagged_types_tu_compatible_p (tree, tree);
  57 static int comp_target_types (tree, tree, int);
  58 static int function_types_compatible_p (tree, tree);
  59 static int type_lists_compatible_p (tree, tree);
  60 static tree decl_constant_value_for_broken_optimization (tree);
  61 static tree default_function_array_conversion (tree);
  62 static tree lookup_field (tree, tree);
  63 static tree convert_arguments (tree, tree, tree, tree);
  64 static tree pointer_diff (tree, tree);
  65 static tree convert_for_assignment (tree, tree, const char *, tree, tree,
  66                                     int);
  67 static void warn_for_assignment (const char *, const char *, tree, int);
  68 static tree valid_compound_expr_initializer (tree, tree);
  69 static void push_string (const char *);
  70 static void push_member_name (tree);
  71 static void push_array_bounds (int);
  72 static int spelling_length (void);
  73 static char *print_spelling (char *);
  74 static void warning_init (const char *);
  75 static tree digest_init (tree, tree, bool, int);
  76 static void output_init_element (tree, bool, tree, tree, int);
  77 static void output_pending_init_elements (int);
  78 static int set_designator (int);
  79 static void push_range_stack (tree);
  80 static void add_pending_init (tree, tree);
  81 static void set_nonincremental_init (void);
  82 static void set_nonincremental_init_from_string (tree);
  83 static tree find_init_member (tree);
  84 static int lvalue_or_else (tree, const char *);
  85 \f
  86 /* Do `exp = require_complete_type (exp);' to make sure exp
  87    does not have an incomplete type.  (That includes void types.)  */
  88
  89 tree
  90 require_complete_type (tree value)
  91 {
  92   tree type = TREE_TYPE (value);
  93
  94   if (value == error_mark_node || type == error_mark_node)
  95     return error_mark_node;
  96
  97   /* First, detect a valid value with a complete type.  */
  98   if (COMPLETE_TYPE_P (type))
  99     return value;
 100
 101   c_incomplete_type_error (value, type);
 102   return error_mark_node;
 103 }
 104
 105 /* Print an error message for invalid use of an incomplete type.
 106    VALUE is the expression that was used (or 0 if that isn't known)
 107    and TYPE is the type that was invalid.  */
 108
 109 void
 110 c_incomplete_type_error (tree value, tree type)
 111 {
 112   const char *type_code_string;
 113
 114   /* Avoid duplicate error message.  */
 115   if (TREE_CODE (type) == ERROR_MARK)
 116     return;
 117
 118   if (value != 0 && (TREE_CODE (value) == VAR_DECL
 119                      || TREE_CODE (value) == PARM_DECL))
 120     error ("`%s' has an incomplete type",
 121            IDENTIFIER_POINTER (DECL_NAME (value)));
 122   else
 123     {
 124     retry:
 125       /* We must print an error message.  Be clever about what it says.  */
 126
 127       switch (TREE_CODE (type))
 128         {
 129         case RECORD_TYPE:
 130           type_code_string = "struct";
 131           break;
 132
 133         case UNION_TYPE:
 134           type_code_string = "union";
 135           break;
 136
 137         case ENUMERAL_TYPE:
 138           type_code_string = "enum";
 139           break;
 140
 141         case VOID_TYPE:
 142           error ("invalid use of void expression");
 143           return;
 144
 145         case ARRAY_TYPE:
 146           if (TYPE_DOMAIN (type))
 147             {
 148               if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
 149                 {
 150                   error ("invalid use of flexible array member");
 151                   return;
 152                 }
 153               type = TREE_TYPE (type);
 154               goto retry;
 155             }
 156           error ("invalid use of array with unspecified bounds");
 157           return;
 158
 159         default:
 160           abort ();
 161         }
 162
 163       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 164         error ("invalid use of undefined type `%s %s'",
 165                type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
 166       else
 167         /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
 168         error ("invalid use of incomplete typedef `%s'",
 169                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
 170     }
 171 }
 172
 173 /* Given a type, apply default promotions wrt unnamed function
 174    arguments and return the new type.  */
 175
 176 tree
 177 c_type_promotes_to (tree type)
 178 {
 179   if (TYPE_MAIN_VARIANT (type) == float_type_node)
 180     return double_type_node;
 181
 182   if (c_promoting_integer_type_p (type))
 183     {
 184       /* Preserve unsignedness if not really getting any wider.  */
 185       if (TYPE_UNSIGNED (type)
 186           && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
 187         return unsigned_type_node;
 188       return integer_type_node;
 189     }
 190
 191   return type;
 192 }
 193
 194 /* Return a variant of TYPE which has all the type qualifiers of LIKE
 195    as well as those of TYPE.  */
 196
 197 static tree
 198 qualify_type (tree type, tree like)
 199 {
 200   return c_build_qualified_type (type,
 201                                  TYPE_QUALS (type) | TYPE_QUALS (like));
 202 }
 203 \f
 204 /* Return the composite type of two compatible types.
 205
 206    We assume that comptypes has already been done and returned
 207    nonzero; if that isn't so, this may crash.  In particular, we
 208    assume that qualifiers match.  */
 209
 210 tree
 211 composite_type (tree t1, tree t2)
 212 {
 213   enum tree_code code1;
 214   enum tree_code code2;
 215   tree attributes;
 216
 217   /* Save time if the two types are the same.  */
 218
 219   if (t1 == t2) return t1;
 220
 221   /* If one type is nonsense, use the other.  */
 222   if (t1 == error_mark_node)
 223     return t2;
 224   if (t2 == error_mark_node)
 225     return t1;
 226
 227   code1 = TREE_CODE (t1);
 228   code2 = TREE_CODE (t2);
 229
 230   /* Merge the attributes.  */
 231   attributes = targetm.merge_type_attributes (t1, t2);
 232
 233   /* If one is an enumerated type and the other is the compatible
 234      integer type, the composite type might be either of the two
 235      (DR#013 question 3).  For consistency, use the enumerated type as
 236      the composite type.  */
 237
 238   if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
 239     return t1;
 240   if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
 241     return t2;
 242
 243   if (code1 != code2)
 244     abort ();
 245
 246   switch (code1)
 247     {
 248     case POINTER_TYPE:
 249       /* For two pointers, do this recursively on the target type.  */
 250       {
 251         tree pointed_to_1 = TREE_TYPE (t1);
 252         tree pointed_to_2 = TREE_TYPE (t2);
 253         tree target = composite_type (pointed_to_1, pointed_to_2);
 254         t1 = build_pointer_type (target);
 255         t1 = build_type_attribute_variant (t1, attributes);
 256         return qualify_type (t1, t2);
 257       }
 258
 259     case ARRAY_TYPE:
 260       {
 261         tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 262
 263         /* We should not have any type quals on arrays at all.  */
 264         if (TYPE_QUALS (t1) || TYPE_QUALS (t2))
 265           abort ();
 266
 267         /* Save space: see if the result is identical to one of the args.  */
 268         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
 269           return build_type_attribute_variant (t1, attributes);
 270         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
 271           return build_type_attribute_variant (t2, attributes);
 272
 273         if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 274           return build_type_attribute_variant (t1, attributes);
 275         if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 276           return build_type_attribute_variant (t2, attributes);
 277
 278         /* Merge the element types, and have a size if either arg has one.  */
 279         t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
 280         return build_type_attribute_variant (t1, attributes);
 281       }
 282
 283     case FUNCTION_TYPE:
 284       /* Function types: prefer the one that specified arg types.
 285          If both do, merge the arg types.  Also merge the return types.  */
 286       {
 287         tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 288         tree p1 = TYPE_ARG_TYPES (t1);
 289         tree p2 = TYPE_ARG_TYPES (t2);
 290         int len;
 291         tree newargs, n;
 292         int i;
 293
 294         /* Save space: see if the result is identical to one of the args.  */
 295         if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
 296           return build_type_attribute_variant (t1, attributes);
 297         if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
 298           return build_type_attribute_variant (t2, attributes);
 299
 300         /* Simple way if one arg fails to specify argument types.  */
 301         if (TYPE_ARG_TYPES (t1) == 0)
 302          {
 303             t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
 304             t1 = build_type_attribute_variant (t1, attributes);
 305             return qualify_type (t1, t2);
 306          }
 307         if (TYPE_ARG_TYPES (t2) == 0)
 308          {
 309            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
 310            t1 = build_type_attribute_variant (t1, attributes);
 311            return qualify_type (t1, t2);
 312          }
 313
 314         /* If both args specify argument types, we must merge the two
 315            lists, argument by argument.  */
 316         /* Tell global_bindings_p to return false so that variable_size
 317            doesn't abort on VLAs in parameter types.  */
 318         c_override_global_bindings_to_false = true;
 319
 320         len = list_length (p1);
 321         newargs = 0;
 322
 323         for (i = 0; i < len; i++)
 324           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 325
 326         n = newargs;
 327
 328         for (; p1;
 329              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
 330           {
 331             /* A null type means arg type is not specified.
 332                Take whatever the other function type has.  */
 333             if (TREE_VALUE (p1) == 0)
 334               {
 335                 TREE_VALUE (n) = TREE_VALUE (p2);
 336                 goto parm_done;
 337               }
 338             if (TREE_VALUE (p2) == 0)
 339               {
 340                 TREE_VALUE (n) = TREE_VALUE (p1);
 341                 goto parm_done;
 342               }
 343
 344             /* Given  wait (union {union wait *u; int *i} *)
 345                and  wait (union wait *),
 346                prefer  union wait *  as type of parm.  */
 347             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
 348                 && TREE_VALUE (p1) != TREE_VALUE (p2))
 349               {
 350                 tree memb;
 351                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
 352                      memb; memb = TREE_CHAIN (memb))
 353                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
 354                     {
 355                       TREE_VALUE (n) = TREE_VALUE (p2);
 356                       if (pedantic)
 357                         pedwarn ("function types not truly compatible in ISO C");
 358                       goto parm_done;
 359                     }
 360               }
 361             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
 362                 && TREE_VALUE (p2) != TREE_VALUE (p1))
 363               {
 364                 tree memb;
 365                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
 366                      memb; memb = TREE_CHAIN (memb))
 367                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
 368                     {
 369                       TREE_VALUE (n) = TREE_VALUE (p1);
 370                       if (pedantic)
 371                         pedwarn ("function types not truly compatible in ISO C");
 372                       goto parm_done;
 373                     }
 374               }
 375             TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
 376           parm_done: ;
 377           }
 378
 379         c_override_global_bindings_to_false = false;
 380         t1 = build_function_type (valtype, newargs);
 381         t1 = qualify_type (t1, t2);
 382         /* ... falls through ...  */
 383       }
 384
 385     default:
 386       return build_type_attribute_variant (t1, attributes);
 387     }
 388
 389 }
 390
 391 /* Return the type of a conditional expression between pointers to
 392    possibly differently qualified versions of compatible types.
 393
 394    We assume that comp_target_types has already been done and returned
 395    nonzero; if that isn't so, this may crash.  */
 396
 397 static tree
 398 common_pointer_type (tree t1, tree t2)
 399 {
 400   tree attributes;
 401   tree pointed_to_1;
 402   tree pointed_to_2;
 403   tree target;
 404
 405   /* Save time if the two types are the same.  */
 406
 407   if (t1 == t2) return t1;
 408
 409   /* If one type is nonsense, use the other.  */
 410   if (t1 == error_mark_node)
 411     return t2;
 412   if (t2 == error_mark_node)
 413     return t1;
 414
 415   if (TREE_CODE (t1) != POINTER_TYPE || TREE_CODE (t2) != POINTER_TYPE)
 416     abort ();
 417
 418   /* Merge the attributes.  */
 419   attributes = targetm.merge_type_attributes (t1, t2);
 420
 421   /* Find the composite type of the target types, and combine the
 422      qualifiers of the two types' targets.  */
 423   pointed_to_1 = TREE_TYPE (t1);
 424   pointed_to_2 = TREE_TYPE (t2);
 425   target = composite_type (TYPE_MAIN_VARIANT (pointed_to_1),
 426                            TYPE_MAIN_VARIANT (pointed_to_2));
 427   t1 = build_pointer_type (c_build_qualified_type
 428                            (target,
 429                             TYPE_QUALS (pointed_to_1) |
 430                             TYPE_QUALS (pointed_to_2)));
 431   return build_type_attribute_variant (t1, attributes);
 432 }
 433
 434 /* Return the common type for two arithmetic types under the usual
 435    arithmetic conversions.  The default conversions have already been
 436    applied, and enumerated types converted to their compatible integer
 437    types.  The resulting type is unqualified and has no attributes.
 438
 439    This is the type for the result of most arithmetic operations
 440    if the operands have the given two types.  */
 441
 442 tree
 443 common_type (tree t1, tree t2)
 444 {
 445   enum tree_code code1;
 446   enum tree_code code2;
 447
 448   /* If one type is nonsense, use the other.  */
 449   if (t1 == error_mark_node)
 450     return t2;
 451   if (t2 == error_mark_node)
 452     return t1;
 453
 454   if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
 455     t1 = TYPE_MAIN_VARIANT (t1);
 456
 457   if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
 458     t2 = TYPE_MAIN_VARIANT (t2);
 459
 460   if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
 461     t1 = build_type_attribute_variant (t1, NULL_TREE);
 462
 463   if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
 464     t2 = build_type_attribute_variant (t2, NULL_TREE);
 465
 466   /* Save time if the two types are the same.  */
 467
 468   if (t1 == t2) return t1;
 469
 470   code1 = TREE_CODE (t1);
 471   code2 = TREE_CODE (t2);
 472
 473   if (code1 != VECTOR_TYPE && code1 != COMPLEX_TYPE
 474       && code1 != REAL_TYPE && code1 != INTEGER_TYPE)
 475     abort ();
 476
 477   if (code2 != VECTOR_TYPE && code2 != COMPLEX_TYPE
 478       && code2 != REAL_TYPE && code2 != INTEGER_TYPE)
 479     abort ();
 480
 481   /* If one type is a vector type, return that type.  (How the usual
 482      arithmetic conversions apply to the vector types extension is not
 483      precisely specified.)  */
 484   if (code1 == VECTOR_TYPE)
 485     return t1;
 486
 487   if (code2 == VECTOR_TYPE)
 488     return t2;
 489
 490   /* If one type is complex, form the common type of the non-complex
 491      components, then make that complex.  Use T1 or T2 if it is the
 492      required type.  */
 493   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 494     {
 495       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
 496       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
 497       tree subtype = common_type (subtype1, subtype2);
 498
 499       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
 500         return t1;
 501       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
 502         return t2;
 503       else
 504         return build_complex_type (subtype);
 505     }
 506
 507   /* If only one is real, use it as the result.  */
 508
 509   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
 510     return t1;
 511
 512   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
 513     return t2;
 514
 515   /* Both real or both integers; use the one with greater precision.  */
 516
 517   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
 518     return t1;
 519   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
 520     return t2;
 521
 522   /* Same precision.  Prefer long longs to longs to ints when the
 523      same precision, following the C99 rules on integer type rank
 524      (which are equivalent to the C90 rules for C90 types).  */
 525
 526   if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
 527       || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
 528     return long_long_unsigned_type_node;
 529
 530   if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
 531       || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
 532     {
 533       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 534         return long_long_unsigned_type_node;
 535       else
 536         return long_long_integer_type_node;
 537     }
 538
 539   if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
 540       || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
 541     return long_unsigned_type_node;
 542
 543   if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
 544       || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
 545     {
 546       /* But preserve unsignedness from the other type,
 547          since long cannot hold all the values of an unsigned int.  */
 548       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 549         return long_unsigned_type_node;
 550       else
 551         return long_integer_type_node;
 552     }
 553
 554   /* Likewise, prefer long double to double even if same size.  */
 555   if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
 556       || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
 557     return long_double_type_node;
 558
 559   /* Otherwise prefer the unsigned one.  */
 560
 561   if (TYPE_UNSIGNED (t1))
 562     return t1;
 563   else
 564     return t2;
 565 }
 566 \f
 567 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 568    or various other operations.  Return 2 if they are compatible
 569    but a warning may be needed if you use them together.  */
 570
 571 int
 572 comptypes (tree type1, tree type2)
 573 {
 574   tree t1 = type1;
 575   tree t2 = type2;
 576   int attrval, val;
 577
 578   /* Suppress errors caused by previously reported errors.  */
 579
 580   if (t1 == t2 || !t1 || !t2
 581       || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
 582     return 1;
 583
 584   /* If either type is the internal version of sizetype, return the
 585      language version.  */
 586   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
 587       && TYPE_ORIG_SIZE_TYPE (t1))
 588     t1 = TYPE_ORIG_SIZE_TYPE (t1);
 589
 590   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
 591       && TYPE_ORIG_SIZE_TYPE (t2))
 592     t2 = TYPE_ORIG_SIZE_TYPE (t2);
 593
 594
 595   /* Enumerated types are compatible with integer types, but this is
 596      not transitive: two enumerated types in the same translation unit
 597      are compatible with each other only if they are the same type.  */
 598
 599   if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
 600     t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
 601   else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
 602     t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
 603
 604   if (t1 == t2)
 605     return 1;
 606
 607   /* Different classes of types can't be compatible.  */
 608
 609   if (TREE_CODE (t1) != TREE_CODE (t2))
 610     return 0;
 611
 612   /* Qualifiers must match. C99 6.7.3p9 */
 613
 614   if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
 615     return 0;
 616
 617   /* Allow for two different type nodes which have essentially the same
 618      definition.  Note that we already checked for equality of the type
 619      qualifiers (just above).  */
 620
 621   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
 622     return 1;
 623
 624   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 625   if (! (attrval = targetm.comp_type_attributes (t1, t2)))
 626      return 0;
 627
 628   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 629   val = 0;
 630
 631   switch (TREE_CODE (t1))
 632     {
 633     case POINTER_TYPE:
 634       /* We must give ObjC the first crack at comparing pointers, since
 635            protocol qualifiers may be involved.  */
 636       if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
 637         break;
 638       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
 639              ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
 640       break;
 641
 642     case FUNCTION_TYPE:
 643       val = function_types_compatible_p (t1, t2);
 644       break;
 645
 646     case ARRAY_TYPE:
 647       {
 648         tree d1 = TYPE_DOMAIN (t1);
 649         tree d2 = TYPE_DOMAIN (t2);
 650         bool d1_variable, d2_variable;
 651         bool d1_zero, d2_zero;
 652         val = 1;
 653
 654         /* Target types must match incl. qualifiers.  */
 655         if (TREE_TYPE (t1) != TREE_TYPE (t2)
 656             && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
 657           return 0;
 658
 659         /* Sizes must match unless one is missing or variable.  */
 660         if (d1 == 0 || d2 == 0 || d1 == d2)
 661           break;
 662
 663         d1_zero = ! TYPE_MAX_VALUE (d1);
 664         d2_zero = ! TYPE_MAX_VALUE (d2);
 665
 666         d1_variable = (! d1_zero
 667                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 668                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
 669         d2_variable = (! d2_zero
 670                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 671                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
 672
 673         if (d1_variable || d2_variable)
 674           break;
 675         if (d1_zero && d2_zero)
 676           break;
 677         if (d1_zero || d2_zero
 678             || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
 679             || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
 680           val = 0;
 681
 682         break;
 683       }
 684
 685     case RECORD_TYPE:
 686       /* We are dealing with two distinct structs.  In assorted Objective-C
 687          corner cases, however, these can still be deemed equivalent.  */
 688       if (c_dialect_objc () && objc_comptypes (t1, t2, 0) == 1)
 689         val = 1;
 690
 691     case ENUMERAL_TYPE:
 692     case UNION_TYPE:
 693       if (val != 1 && !same_translation_unit_p (t1, t2))
 694         val = tagged_types_tu_compatible_p (t1, t2);
 695       break;
 696
 697     case VECTOR_TYPE:
 698       val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
 699             && comptypes (TREE_TYPE (t1), TREE_TYPE (t2));
 700       break;
 701
 702     default:
 703       break;
 704     }
 705   return attrval == 2 && val == 1 ? 2 : val;
 706 }
 707
 708 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
 709    ignoring their qualifiers.  REFLEXIVE is only used by ObjC - set it
 710    to 1 or 0 depending if the check of the pointer types is meant to
 711    be reflexive or not (typically, assignments are not reflexive,
 712    while comparisons are reflexive).
 713 */
 714
 715 static int
 716 comp_target_types (tree ttl, tree ttr, int reflexive)
 717 {
 718   int val;
 719
 720   /* Give objc_comptypes a crack at letting these types through.  */
 721   if ((val = objc_comptypes (ttl, ttr, reflexive)) >= 0)
 722     return val;
 723
 724   val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
 725                    TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
 726
 727   if (val == 2 && pedantic)
 728     pedwarn ("types are not quite compatible");
 729   return val;
 730 }
 731 \f
 732 /* Subroutines of `comptypes'.  */
 733
 734 /* Determine whether two trees derive from the same translation unit.
 735    If the CONTEXT chain ends in a null, that tree's context is still
 736    being parsed, so if two trees have context chains ending in null,
 737    they're in the same translation unit.  */
 738 int
 739 same_translation_unit_p (tree t1, tree t2)
 740 {
 741   while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
 742     switch (TREE_CODE_CLASS (TREE_CODE (t1)))
 743       {
 744       case 'd': t1 = DECL_CONTEXT (t1); break;
 745       case 't': t1 = TYPE_CONTEXT (t1); break;
 746       case 'x': t1 = BLOCK_SUPERCONTEXT (t1); break;  /* assume block */
 747       default: abort ();
 748       }
 749
 750   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
 751     switch (TREE_CODE_CLASS (TREE_CODE (t2)))
 752       {
 753       case 'd': t2 = DECL_CONTEXT (t2); break;
 754       case 't': t2 = TYPE_CONTEXT (t2); break;
 755       case 'x': t2 = BLOCK_SUPERCONTEXT (t2); break;  /* assume block */
 756       default: abort ();
 757       }
 758
 759   return t1 == t2;
 760 }
 761
 762 /* The C standard says that two structures in different translation
 763    units are compatible with each other only if the types of their
 764    fields are compatible (among other things).  So, consider two copies
 765    of this structure:  */
 766
 767 struct tagged_tu_seen {
 768   const struct tagged_tu_seen * next;
 769   tree t1;
 770   tree t2;
 771 };
 772
 773 /* Can they be compatible with each other?  We choose to break the
 774    recursion by allowing those types to be compatible.  */
 775
 776 static const struct tagged_tu_seen * tagged_tu_seen_base;
 777
 778 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
 779    compatible.  If the two types are not the same (which has been
 780    checked earlier), this can only happen when multiple translation
 781    units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
 782    rules.  */
 783
 784 static int
 785 tagged_types_tu_compatible_p (tree t1, tree t2)
 786 {
 787   tree s1, s2;
 788   bool needs_warning = false;
 789
 790   /* We have to verify that the tags of the types are the same.  This
 791      is harder than it looks because this may be a typedef, so we have
 792      to go look at the original type.  It may even be a typedef of a
 793      typedef...
 794      In the case of compiler-created builtin structs the TYPE_DECL
 795      may be a dummy, with no DECL_ORIGINAL_TYPE.  Don't fault.  */
 796   while (TYPE_NAME (t1)
 797          && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
 798          && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
 799     t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
 800
 801   while (TYPE_NAME (t2)
 802          && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
 803          && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
 804     t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
 805
 806   /* C90 didn't have the requirement that the two tags be the same.  */
 807   if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
 808     return 0;
 809
 810   /* C90 didn't say what happened if one or both of the types were
 811      incomplete; we choose to follow C99 rules here, which is that they
 812      are compatible.  */
 813   if (TYPE_SIZE (t1) == NULL
 814       || TYPE_SIZE (t2) == NULL)
 815     return 1;
 816
 817   {
 818     const struct tagged_tu_seen * tts_i;
 819     for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
 820       if (tts_i->t1 == t1 && tts_i->t2 == t2)
 821         return 1;
 822   }
 823
 824   switch (TREE_CODE (t1))
 825     {
 826     case ENUMERAL_TYPE:
 827       {
 828
 829         /* Speed up the case where the type values are in the same order.  */
 830         tree tv1 = TYPE_VALUES (t1);
 831         tree tv2 = TYPE_VALUES (t2);
 832
 833         if (tv1 == tv2)
 834           return 1;
 835
 836         for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
 837           {
 838             if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
 839               break;
 840             if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
 841               return 0;
 842           }
 843
 844         if (tv1 == NULL_TREE && tv2 == NULL_TREE)
 845           return 1;
 846         if (tv1 == NULL_TREE || tv2 == NULL_TREE)
 847           return 0;
 848
 849         if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
 850           return 0;
 851
 852         for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
 853           {
 854             s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
 855             if (s2 == NULL
 856                 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
 857               return 0;
 858           }
 859         return 1;
 860       }
 861
 862     case UNION_TYPE:
 863       {
 864         if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
 865           return 0;
 866
 867         for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
 868           {
 869             bool ok = false;
 870             struct tagged_tu_seen tts;
 871
 872             tts.next = tagged_tu_seen_base;
 873             tts.t1 = t1;
 874             tts.t2 = t2;
 875             tagged_tu_seen_base = &tts;
 876
 877             if (DECL_NAME (s1) != NULL)
 878               for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
 879                 if (DECL_NAME (s1) == DECL_NAME (s2))
 880                   {
 881                     int result;
 882                     result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
 883                     if (result == 0)
 884                       break;
 885                     if (result == 2)
 886                       needs_warning = true;
 887
 888                     if (TREE_CODE (s1) == FIELD_DECL
 889                         && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
 890                                              DECL_FIELD_BIT_OFFSET (s2)) != 1)
 891                       break;
 892
 893                     ok = true;
 894                     break;
 895                   }
 896             tagged_tu_seen_base = tts.next;
 897             if (! ok)
 898               return 0;
 899           }
 900         return needs_warning ? 2 : 1;
 901       }
 902
 903     case RECORD_TYPE:
 904       {
 905         struct tagged_tu_seen tts;
 906
 907         tts.next = tagged_tu_seen_base;
 908         tts.t1 = t1;
 909         tts.t2 = t2;
 910         tagged_tu_seen_base = &tts;
 911
 912         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
 913              s1 && s2;
 914              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
 915           {
 916             int result;
 917             if (TREE_CODE (s1) != TREE_CODE (s2)
 918                 || DECL_NAME (s1) != DECL_NAME (s2))
 919               break;
 920             result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
 921             if (result == 0)
 922               break;
 923             if (result == 2)
 924               needs_warning = true;
 925
 926             if (TREE_CODE (s1) == FIELD_DECL
 927                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
 928                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
 929               break;
 930           }
 931         tagged_tu_seen_base = tts.next;
 932         if (s1 && s2)
 933           return 0;
 934         return needs_warning ? 2 : 1;
 935       }
 936
 937     default:
 938       abort ();
 939     }
 940 }
 941
 942 /* Return 1 if two function types F1 and F2 are compatible.
 943    If either type specifies no argument types,
 944    the other must specify a fixed number of self-promoting arg types.
 945    Otherwise, if one type specifies only the number of arguments,
 946    the other must specify that number of self-promoting arg types.
 947    Otherwise, the argument types must match.  */
 948
 949 static int
 950 function_types_compatible_p (tree f1, tree f2)
 951 {
 952   tree args1, args2;
 953   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 954   int val = 1;
 955   int val1;
 956   tree ret1, ret2;
 957
 958   ret1 = TREE_TYPE (f1);
 959   ret2 = TREE_TYPE (f2);
 960
 961   /* 'volatile' qualifiers on a function's return type used to mean
 962      the function is noreturn.  */
 963   if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
 964     pedwarn ("function return types not compatible due to `volatile'");
 965   if (TYPE_VOLATILE (ret1))
 966     ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
 967                                  TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
 968   if (TYPE_VOLATILE (ret2))
 969     ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
 970                                  TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
 971   val = comptypes (ret1, ret2);
 972   if (val == 0)
 973     return 0;
 974
 975   args1 = TYPE_ARG_TYPES (f1);
 976   args2 = TYPE_ARG_TYPES (f2);
 977
 978   /* An unspecified parmlist matches any specified parmlist
 979      whose argument types don't need default promotions.  */
 980
 981   if (args1 == 0)
 982     {
 983       if (!self_promoting_args_p (args2))
 984         return 0;
 985       /* If one of these types comes from a non-prototype fn definition,
 986          compare that with the other type's arglist.
 987          If they don't match, ask for a warning (but no error).  */
 988       if (TYPE_ACTUAL_ARG_TYPES (f1)
 989           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
 990         val = 2;
 991       return val;
 992     }
 993   if (args2 == 0)
 994     {
 995       if (!self_promoting_args_p (args1))
 996         return 0;
 997       if (TYPE_ACTUAL_ARG_TYPES (f2)
 998           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
 999         val = 2;
1000       return val;
1001     }
1002
1003   /* Both types have argument lists: compare them and propagate results.  */
1004   val1 = type_lists_compatible_p (args1, args2);
1005   return val1 != 1 ? val1 : val;
1006 }
1007
1008 /* Check two lists of types for compatibility,
1009    returning 0 for incompatible, 1 for compatible,
1010    or 2 for compatible with warning.  */
1011
1012 static int
1013 type_lists_compatible_p (tree args1, tree args2)
1014 {
1015   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1016   int val = 1;
1017   int newval = 0;
1018
1019   while (1)
1020     {
1021       if (args1 == 0 && args2 == 0)
1022         return val;
1023       /* If one list is shorter than the other,
1024          they fail to match.  */
1025       if (args1 == 0 || args2 == 0)
1026         return 0;
1027       /* A null pointer instead of a type
1028          means there is supposed to be an argument
1029          but nothing is specified about what type it has.
1030          So match anything that self-promotes.  */
1031       if (TREE_VALUE (args1) == 0)
1032         {
1033           if (c_type_promotes_to (TREE_VALUE (args2)) != TREE_VALUE (args2))
1034             return 0;
1035         }
1036       else if (TREE_VALUE (args2) == 0)
1037         {
1038           if (c_type_promotes_to (TREE_VALUE (args1)) != TREE_VALUE (args1))
1039             return 0;
1040         }
1041       /* If one of the lists has an error marker, ignore this arg.  */
1042       else if (TREE_CODE (TREE_VALUE (args1)) == ERROR_MARK
1043                || TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
1044         ;
1045       else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
1046                                       TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
1047         {
1048           /* Allow  wait (union {union wait *u; int *i} *)
1049              and  wait (union wait *)  to be compatible.  */
1050           if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
1051               && (TYPE_NAME (TREE_VALUE (args1)) == 0
1052                   || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
1053               && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
1054               && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
1055                                      TYPE_SIZE (TREE_VALUE (args2))))
1056             {
1057               tree memb;
1058               for (memb = TYPE_FIELDS (TREE_VALUE (args1));
1059                    memb; memb = TREE_CHAIN (memb))
1060                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
1061                   break;
1062               if (memb == 0)
1063                 return 0;
1064             }
1065           else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
1066                    && (TYPE_NAME (TREE_VALUE (args2)) == 0
1067                        || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
1068                    && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
1069                    && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
1070                                           TYPE_SIZE (TREE_VALUE (args1))))
1071             {
1072               tree memb;
1073               for (memb = TYPE_FIELDS (TREE_VALUE (args2));
1074                    memb; memb = TREE_CHAIN (memb))
1075                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
1076                   break;
1077               if (memb == 0)
1078                 return 0;
1079             }
1080           else
1081             return 0;
1082         }
1083
1084       /* comptypes said ok, but record if it said to warn.  */
1085       if (newval > val)
1086         val = newval;
1087
1088       args1 = TREE_CHAIN (args1);
1089       args2 = TREE_CHAIN (args2);
1090     }
1091 }
1092 \f
1093 /* Compute the size to increment a pointer by.  */
1094
1095 tree
1096 c_size_in_bytes (tree type)
1097 {
1098   enum tree_code code = TREE_CODE (type);
1099
1100   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1101     return size_one_node;
1102
1103   if (!COMPLETE_OR_VOID_TYPE_P (type))
1104     {
1105       error ("arithmetic on pointer to an incomplete type");
1106       return size_one_node;
1107     }
1108
1109   /* Convert in case a char is more than one unit.  */
1110   return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1111                      size_int (TYPE_PRECISION (char_type_node)
1112                                / BITS_PER_UNIT));
1113 }
1114 \f
1115 /* Return either DECL or its known constant value (if it has one).  */
1116
1117 tree
1118 decl_constant_value (tree decl)
1119 {
1120   if (/* Don't change a variable array bound or initial value to a constant
1121          in a place where a variable is invalid.  Note that DECL_INITIAL
1122          isn't valid for a PARM_DECL.  */
1123       current_function_decl != 0
1124       && TREE_CODE (decl) != PARM_DECL
1125       && ! TREE_THIS_VOLATILE (decl)
1126       && TREE_READONLY (decl)
1127       && DECL_INITIAL (decl) != 0
1128       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1129       /* This is invalid if initial value is not constant.
1130          If it has either a function call, a memory reference,
1131          or a variable, then re-evaluating it could give different results.  */
1132       && TREE_CONSTANT (DECL_INITIAL (decl))
1133       /* Check for cases where this is sub-optimal, even though valid.  */
1134       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1135     return DECL_INITIAL (decl);
1136   return decl;
1137 }
1138
1139 /* Return either DECL or its known constant value (if it has one), but
1140    return DECL if pedantic or DECL has mode BLKmode.  This is for
1141    bug-compatibility with the old behavior of decl_constant_value
1142    (before GCC 3.0); every use of this function is a bug and it should
1143    be removed before GCC 3.1.  It is not appropriate to use pedantic
1144    in a way that affects optimization, and BLKmode is probably not the
1145    right test for avoiding misoptimizations either.  */
1146
1147 static tree
1148 decl_constant_value_for_broken_optimization (tree decl)
1149 {
1150   if (pedantic || DECL_MODE (decl) == BLKmode)
1151     return decl;
1152   else
1153     return decl_constant_value (decl);
1154 }
1155
1156
1157 /* Perform the default conversion of arrays and functions to pointers.
1158    Return the result of converting EXP.  For any other expression, just
1159    return EXP.  */
1160
1161 static tree
1162 default_function_array_conversion (tree exp)
1163 {
1164   tree orig_exp;
1165   tree type = TREE_TYPE (exp);
1166   enum tree_code code = TREE_CODE (type);
1167   int not_lvalue = 0;
1168
1169   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1170      an lvalue.
1171
1172      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1173      to integer and cause infinite recursion.  */
1174   orig_exp = exp;
1175   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1176          || (TREE_CODE (exp) == NOP_EXPR
1177              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1178     {
1179       if (TREE_CODE (exp) == NON_LVALUE_EXPR)
1180         not_lvalue = 1;
1181       exp = TREE_OPERAND (exp, 0);
1182     }
1183
1184   if (TREE_NO_WARNING (orig_exp))
1185     TREE_NO_WARNING (exp) = 1;
1186
1187   if (code == FUNCTION_TYPE)
1188     {
1189       return build_unary_op (ADDR_EXPR, exp, 0);
1190     }
1191   if (code == ARRAY_TYPE)
1192     {
1193       tree adr;
1194       tree restype = TREE_TYPE (type);
1195       tree ptrtype;
1196       int constp = 0;
1197       int volatilep = 0;
1198       int lvalue_array_p;
1199
1200       if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
1201         {
1202           constp = TREE_READONLY (exp);
1203           volatilep = TREE_THIS_VOLATILE (exp);
1204         }
1205
1206       if (TYPE_QUALS (type) || constp || volatilep)
1207         restype
1208           = c_build_qualified_type (restype,
1209                                     TYPE_QUALS (type)
1210                                     | (constp * TYPE_QUAL_CONST)
1211                                     | (volatilep * TYPE_QUAL_VOLATILE));
1212
1213       if (TREE_CODE (exp) == INDIRECT_REF)
1214         return convert (build_pointer_type (restype),
1215                         TREE_OPERAND (exp, 0));
1216
1217       if (TREE_CODE (exp) == COMPOUND_EXPR)
1218         {
1219           tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1220           return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1221                          TREE_OPERAND (exp, 0), op1);
1222         }
1223
1224       lvalue_array_p = !not_lvalue && lvalue_p (exp);
1225       if (!flag_isoc99 && !lvalue_array_p)
1226         {
1227           /* Before C99, non-lvalue arrays do not decay to pointers.
1228              Normally, using such an array would be invalid; but it can
1229              be used correctly inside sizeof or as a statement expression.
1230              Thus, do not give an error here; an error will result later.  */
1231           return exp;
1232         }
1233
1234       ptrtype = build_pointer_type (restype);
1235
1236       if (TREE_CODE (exp) == VAR_DECL)
1237         {
1238           /* We are making an ADDR_EXPR of ptrtype.  This is a valid
1239              ADDR_EXPR because it's the best way of representing what
1240              happens in C when we take the address of an array and place
1241              it in a pointer to the element type.  */
1242           adr = build1 (ADDR_EXPR, ptrtype, exp);
1243           if (!c_mark_addressable (exp))
1244             return error_mark_node;
1245           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1246           return adr;
1247         }
1248       /* This way is better for a COMPONENT_REF since it can
1249          simplify the offset for a component.  */
1250       adr = build_unary_op (ADDR_EXPR, exp, 1);
1251       return convert (ptrtype, adr);
1252     }
1253   return exp;
1254 }
1255
1256 /* Perform default promotions for C data used in expressions.
1257    Arrays and functions are converted to pointers;
1258    enumeral types or short or char, to int.
1259    In addition, manifest constants symbols are replaced by their values.  */
1260
1261 tree
1262 default_conversion (tree exp)
1263 {
1264   tree orig_exp;
1265   tree type = TREE_TYPE (exp);
1266   enum tree_code code = TREE_CODE (type);
1267
1268   if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
1269     return default_function_array_conversion (exp);
1270
1271   /* Constants can be used directly unless they're not loadable.  */
1272   if (TREE_CODE (exp) == CONST_DECL)
1273     exp = DECL_INITIAL (exp);
1274
1275   /* Replace a nonvolatile const static variable with its value unless
1276      it is an array, in which case we must be sure that taking the
1277      address of the array produces consistent results.  */
1278   else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1279     {
1280       exp = decl_constant_value_for_broken_optimization (exp);
1281       type = TREE_TYPE (exp);
1282     }
1283
1284   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1285      an lvalue.
1286
1287      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1288      to integer and cause infinite recursion.  */
1289   orig_exp = exp;
1290   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1291          || (TREE_CODE (exp) == NOP_EXPR
1292              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1293     exp = TREE_OPERAND (exp, 0);
1294
1295   if (TREE_NO_WARNING (orig_exp))
1296     TREE_NO_WARNING (exp) = 1;
1297
1298   /* Normally convert enums to int,
1299      but convert wide enums to something wider.  */
1300   if (code == ENUMERAL_TYPE)
1301     {
1302       type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1303                                           TYPE_PRECISION (integer_type_node)),
1304                                      ((TYPE_PRECISION (type)
1305                                        >= TYPE_PRECISION (integer_type_node))
1306                                       && TYPE_UNSIGNED (type)));
1307
1308       return convert (type, exp);
1309     }
1310
1311   if (TREE_CODE (exp) == COMPONENT_REF
1312       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1313       /* If it's thinner than an int, promote it like a
1314          c_promoting_integer_type_p, otherwise leave it alone.  */
1315       && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1316                                TYPE_PRECISION (integer_type_node)))
1317     return convert (integer_type_node, exp);
1318
1319   if (c_promoting_integer_type_p (type))
1320     {
1321       /* Preserve unsignedness if not really getting any wider.  */
1322       if (TYPE_UNSIGNED (type)
1323           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1324         return convert (unsigned_type_node, exp);
1325
1326       return convert (integer_type_node, exp);
1327     }
1328
1329   if (code == VOID_TYPE)
1330     {
1331       error ("void value not ignored as it ought to be");
1332       return error_mark_node;
1333     }
1334   return exp;
1335 }
1336 \f
1337 /* Look up COMPONENT in a structure or union DECL.
1338
1339    If the component name is not found, returns NULL_TREE.  Otherwise,
1340    the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1341    stepping down the chain to the component, which is in the last
1342    TREE_VALUE of the list.  Normally the list is of length one, but if
1343    the component is embedded within (nested) anonymous structures or
1344    unions, the list steps down the chain to the component.  */
1345
1346 static tree
1347 lookup_field (tree decl, tree component)
1348 {
1349   tree type = TREE_TYPE (decl);
1350   tree field;
1351
1352   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1353      to the field elements.  Use a binary search on this array to quickly
1354      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1355      will always be set for structures which have many elements.  */
1356
1357   if (TYPE_LANG_SPECIFIC (type))
1358     {
1359       int bot, top, half;
1360       tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1361
1362       field = TYPE_FIELDS (type);
1363       bot = 0;
1364       top = TYPE_LANG_SPECIFIC (type)->s->len;
1365       while (top - bot > 1)
1366         {
1367           half = (top - bot + 1) >> 1;
1368           field = field_array[bot+half];
1369
1370           if (DECL_NAME (field) == NULL_TREE)
1371             {
1372               /* Step through all anon unions in linear fashion.  */
1373               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1374                 {
1375                   field = field_array[bot++];
1376                   if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1377                       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1378                     {
1379                       tree anon = lookup_field (field, component);
1380
1381                       if (anon)
1382                         return tree_cons (NULL_TREE, field, anon);
1383                     }
1384                 }
1385
1386               /* Entire record is only anon unions.  */
1387               if (bot > top)
1388                 return NULL_TREE;
1389
1390               /* Restart the binary search, with new lower bound.  */
1391               continue;
1392             }
1393
1394           if (DECL_NAME (field) == component)
1395             break;
1396           if (DECL_NAME (field) < component)
1397             bot += half;
1398           else
1399             top = bot + half;
1400         }
1401
1402       if (DECL_NAME (field_array[bot]) == component)
1403         field = field_array[bot];
1404       else if (DECL_NAME (field) != component)
1405         return NULL_TREE;
1406     }
1407   else
1408     {
1409       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1410         {
1411           if (DECL_NAME (field) == NULL_TREE
1412               && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1413                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1414             {
1415               tree anon = lookup_field (field, component);
1416
1417               if (anon)
1418                 return tree_cons (NULL_TREE, field, anon);
1419             }
1420
1421           if (DECL_NAME (field) == component)
1422             break;
1423         }
1424
1425       if (field == NULL_TREE)
1426         return NULL_TREE;
1427     }
1428
1429   return tree_cons (NULL_TREE, field, NULL_TREE);
1430 }
1431
1432 /* Make an expression to refer to the COMPONENT field of
1433    structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
1434
1435 tree
1436 build_component_ref (tree datum, tree component)
1437 {
1438   tree type = TREE_TYPE (datum);
1439   enum tree_code code = TREE_CODE (type);
1440   tree field = NULL;
1441   tree ref;
1442
1443   if (!objc_is_public (datum, component))
1444     return error_mark_node;
1445
1446   /* If DATUM is a COMPOUND_EXPR, move our reference inside it.
1447      Ensure that the arguments are not lvalues; otherwise,
1448      if the component is an array, it would wrongly decay to a pointer in
1449      C89 mode.
1450      We cannot do this with a COND_EXPR, because in a conditional expression
1451      the default promotions are applied to both sides, and this would yield
1452      the wrong type of the result; for example, if the components have
1453      type "char".  */
1454   switch (TREE_CODE (datum))
1455     {
1456     case COMPOUND_EXPR:
1457       {
1458         tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1459         return build2 (COMPOUND_EXPR, TREE_TYPE (value),
1460                        TREE_OPERAND (datum, 0), non_lvalue (value));
1461       }
1462     default:
1463       break;
1464     }
1465
1466   /* See if there is a field or component with name COMPONENT.  */
1467
1468   if (code == RECORD_TYPE || code == UNION_TYPE)
1469     {
1470       if (!COMPLETE_TYPE_P (type))
1471         {
1472           c_incomplete_type_error (NULL_TREE, type);
1473           return error_mark_node;
1474         }
1475
1476       field = lookup_field (datum, component);
1477
1478       if (!field)
1479         {
1480           error ("%s has no member named `%s'",
1481                  code == RECORD_TYPE ? "structure" : "union",
1482                  IDENTIFIER_POINTER (component));
1483           return error_mark_node;
1484         }
1485
1486       /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1487          This might be better solved in future the way the C++ front
1488          end does it - by giving the anonymous entities each a
1489          separate name and type, and then have build_component_ref
1490          recursively call itself.  We can't do that here.  */
1491       do
1492         {
1493           tree subdatum = TREE_VALUE (field);
1494
1495           if (TREE_TYPE (subdatum) == error_mark_node)
1496             return error_mark_node;
1497
1498           ref = build3 (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum,
1499                         NULL_TREE);
1500           if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1501             TREE_READONLY (ref) = 1;
1502           if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1503             TREE_THIS_VOLATILE (ref) = 1;
1504
1505           if (TREE_DEPRECATED (subdatum))
1506             warn_deprecated_use (subdatum);
1507
1508           datum = ref;
1509
1510           field = TREE_CHAIN (field);
1511         }
1512       while (field);
1513
1514       return ref;
1515     }
1516   else if (code != ERROR_MARK)
1517     error ("request for member `%s' in something not a structure or union",
1518             IDENTIFIER_POINTER (component));
1519
1520   return error_mark_node;
1521 }
1522 \f
1523 /* Given an expression PTR for a pointer, return an expression
1524    for the value pointed to.
1525    ERRORSTRING is the name of the operator to appear in error messages.  */
1526
1527 tree
1528 build_indirect_ref (tree ptr, const char *errorstring)
1529 {
1530   tree pointer = default_conversion (ptr);
1531   tree type = TREE_TYPE (pointer);
1532
1533   if (TREE_CODE (type) == POINTER_TYPE)
1534     {
1535       if (TREE_CODE (pointer) == ADDR_EXPR
1536           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1537               == TREE_TYPE (type)))
1538         return TREE_OPERAND (pointer, 0);
1539       else
1540         {
1541           tree t = TREE_TYPE (type);
1542           tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1543
1544           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1545             {
1546               error ("dereferencing pointer to incomplete type");
1547               return error_mark_node;
1548             }
1549           if (VOID_TYPE_P (t) && skip_evaluation == 0)
1550             warning ("dereferencing `void *' pointer");
1551
1552           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1553              so that we get the proper error message if the result is used
1554              to assign to.  Also, &* is supposed to be a no-op.
1555              And ANSI C seems to specify that the type of the result
1556              should be the const type.  */
1557           /* A de-reference of a pointer to const is not a const.  It is valid
1558              to change it via some other pointer.  */
1559           TREE_READONLY (ref) = TYPE_READONLY (t);
1560           TREE_SIDE_EFFECTS (ref)
1561             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1562           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1563           return ref;
1564         }
1565     }
1566   else if (TREE_CODE (pointer) != ERROR_MARK)
1567     error ("invalid type argument of `%s'", errorstring);
1568   return error_mark_node;
1569 }
1570
1571 /* This handles expressions of the form "a[i]", which denotes
1572    an array reference.
1573
1574    This is logically equivalent in C to *(a+i), but we may do it differently.
1575    If A is a variable or a member, we generate a primitive ARRAY_REF.
1576    This avoids forcing the array out of registers, and can work on
1577    arrays that are not lvalues (for example, members of structures returned
1578    by functions).  */
1579
1580 tree
1581 build_array_ref (tree array, tree index)
1582 {
1583   if (index == 0)
1584     {
1585       error ("subscript missing in array reference");
1586       return error_mark_node;
1587     }
1588
1589   if (TREE_TYPE (array) == error_mark_node
1590       || TREE_TYPE (index) == error_mark_node)
1591     return error_mark_node;
1592
1593   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
1594     {
1595       tree rval, type;
1596
1597       /* Subscripting with type char is likely to lose
1598          on a machine where chars are signed.
1599          So warn on any machine, but optionally.
1600          Don't warn for unsigned char since that type is safe.
1601          Don't warn for signed char because anyone who uses that
1602          must have done so deliberately.  */
1603       if (warn_char_subscripts
1604           && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1605         warning ("array subscript has type `char'");
1606
1607       /* Apply default promotions *after* noticing character types.  */
1608       index = default_conversion (index);
1609
1610       /* Require integer *after* promotion, for sake of enums.  */
1611       if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1612         {
1613           error ("array subscript is not an integer");
1614           return error_mark_node;
1615         }
1616
1617       /* An array that is indexed by a non-constant
1618          cannot be stored in a register; we must be able to do
1619          address arithmetic on its address.
1620          Likewise an array of elements of variable size.  */
1621       if (TREE_CODE (index) != INTEGER_CST
1622           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1623               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1624         {
1625           if (!c_mark_addressable (array))
1626             return error_mark_node;
1627         }
1628       /* An array that is indexed by a constant value which is not within
1629          the array bounds cannot be stored in a register either; because we
1630          would get a crash in store_bit_field/extract_bit_field when trying
1631          to access a non-existent part of the register.  */
1632       if (TREE_CODE (index) == INTEGER_CST
1633           && TYPE_DOMAIN (TREE_TYPE (array))
1634           && ! int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
1635         {
1636           if (!c_mark_addressable (array))
1637             return error_mark_node;
1638         }
1639
1640       if (pedantic)
1641         {
1642           tree foo = array;
1643           while (TREE_CODE (foo) == COMPONENT_REF)
1644             foo = TREE_OPERAND (foo, 0);
1645           if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
1646             pedwarn ("ISO C forbids subscripting `register' array");
1647           else if (! flag_isoc99 && ! lvalue_p (foo))
1648             pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1649         }
1650
1651       type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1652       rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
1653       /* Array ref is const/volatile if the array elements are
1654          or if the array is.  */
1655       TREE_READONLY (rval)
1656         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1657             | TREE_READONLY (array));
1658       TREE_SIDE_EFFECTS (rval)
1659         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1660             | TREE_SIDE_EFFECTS (array));
1661       TREE_THIS_VOLATILE (rval)
1662         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1663             /* This was added by rms on 16 Nov 91.
1664                It fixes  vol struct foo *a;  a->elts[1]
1665                in an inline function.
1666                Hope it doesn't break something else.  */
1667             | TREE_THIS_VOLATILE (array));
1668       return require_complete_type (fold (rval));
1669     }
1670
1671   {
1672     tree ar = default_conversion (array);
1673     tree ind = default_conversion (index);
1674
1675     /* Do the same warning check as above, but only on the part that's
1676        syntactically the index and only if it is also semantically
1677        the index.  */
1678     if (warn_char_subscripts
1679         && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1680         && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1681       warning ("subscript has type `char'");
1682
1683     /* Put the integer in IND to simplify error checking.  */
1684     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1685       {
1686         tree temp = ar;
1687         ar = ind;
1688         ind = temp;
1689       }
1690
1691     if (ar == error_mark_node)
1692       return ar;
1693
1694     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1695         || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1696       {
1697         error ("subscripted value is neither array nor pointer");
1698         return error_mark_node;
1699       }
1700     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1701       {
1702         error ("array subscript is not an integer");
1703         return error_mark_node;
1704       }
1705
1706     return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1707                                "array indexing");
1708   }
1709 }
1710 \f
1711 /* Build an external reference to identifier ID.  FUN indicates
1712    whether this will be used for a function call.  */
1713 tree
1714 build_external_ref (tree id, int fun)
1715 {
1716   tree ref;
1717   tree decl = lookup_name (id);
1718   tree objc_ivar = lookup_objc_ivar (id);
1719
1720   if (decl && decl != error_mark_node)
1721     {
1722       /* Properly declared variable or function reference.  */
1723       if (!objc_ivar)
1724         ref = decl;
1725       else if (decl != objc_ivar && !DECL_FILE_SCOPE_P (decl))
1726         {
1727           warning ("local declaration of `%s' hides instance variable",
1728                    IDENTIFIER_POINTER (id));
1729           ref = decl;
1730         }
1731       else
1732         ref = objc_ivar;
1733     }
1734   else if (objc_ivar)
1735     ref = objc_ivar;
1736   else if (fun)
1737     /* Implicit function declaration.  */
1738     ref = implicitly_declare (id);
1739   else if (decl == error_mark_node)
1740     /* Don't complain about something that's already been
1741        complained about.  */
1742     return error_mark_node;
1743   else
1744     {
1745       undeclared_variable (id);
1746       return error_mark_node;
1747     }
1748
1749   if (TREE_TYPE (ref) == error_mark_node)
1750     return error_mark_node;
1751
1752   if (TREE_DEPRECATED (ref))
1753     warn_deprecated_use (ref);
1754
1755   if (!skip_evaluation)
1756     assemble_external (ref);
1757   TREE_USED (ref) = 1;
1758
1759   if (TREE_CODE (ref) == CONST_DECL)
1760     {
1761       ref = DECL_INITIAL (ref);
1762       TREE_CONSTANT (ref) = 1;
1763       TREE_INVARIANT (ref) = 1;
1764     }
1765   else if (current_function_decl != 0
1766            && !DECL_FILE_SCOPE_P (current_function_decl)
1767            && (TREE_CODE (ref) == VAR_DECL
1768                || TREE_CODE (ref) == PARM_DECL
1769                || TREE_CODE (ref) == FUNCTION_DECL))
1770     {
1771       tree context = decl_function_context (ref);
1772
1773       if (context != 0 && context != current_function_decl)
1774         DECL_NONLOCAL (ref) = 1;
1775     }
1776
1777   return ref;
1778 }
1779
1780 /* Build a function call to function FUNCTION with parameters PARAMS.
1781    PARAMS is a list--a chain of TREE_LIST nodes--in which the
1782    TREE_VALUE of each node is a parameter-expression.
1783    FUNCTION's data type may be a function type or a pointer-to-function.  */
1784
1785 tree
1786 build_function_call (tree function, tree params)
1787 {
1788   tree fntype, fundecl = 0;
1789   tree coerced_params;
1790   tree name = NULL_TREE, result;
1791   tree tem;
1792
1793   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1794   STRIP_TYPE_NOPS (function);
1795
1796   /* Convert anything with function type to a pointer-to-function.  */
1797   if (TREE_CODE (function) == FUNCTION_DECL)
1798     {
1799       name = DECL_NAME (function);
1800
1801       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1802          (because calling an inline function does not mean the function
1803          needs to be separately compiled).  */
1804       fntype = build_type_variant (TREE_TYPE (function),
1805                                    TREE_READONLY (function),
1806                                    TREE_THIS_VOLATILE (function));
1807       fundecl = function;
1808       function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1809     }
1810   else
1811     function = default_conversion (function);
1812
1813   fntype = TREE_TYPE (function);
1814
1815   if (TREE_CODE (fntype) == ERROR_MARK)
1816     return error_mark_node;
1817
1818   if (!(TREE_CODE (fntype) == POINTER_TYPE
1819         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1820     {
1821       error ("called object is not a function");
1822       return error_mark_node;
1823     }
1824
1825   if (fundecl && TREE_THIS_VOLATILE (fundecl))
1826     current_function_returns_abnormally = 1;
1827
1828   /* fntype now gets the type of function pointed to.  */
1829   fntype = TREE_TYPE (fntype);
1830
1831   /* Check that the function is called through a compatible prototype.
1832      If it is not, replace the call by a trap, wrapped up in a compound
1833      expression if necessary.  This has the nice side-effect to prevent
1834      the tree-inliner from generating invalid assignment trees which may
1835      blow up in the RTL expander later.
1836
1837      ??? This doesn't work for Objective-C because objc_comptypes
1838      refuses to compare function prototypes, yet the compiler appears
1839      to build calls that are flagged as invalid by C's comptypes.  */
1840   if (! c_dialect_objc ()
1841       && TREE_CODE (function) == NOP_EXPR
1842       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
1843       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
1844       && ! comptypes (fntype, TREE_TYPE (tem)))
1845     {
1846       tree return_type = TREE_TYPE (fntype);
1847       tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
1848                                        NULL_TREE);
1849
1850       /* This situation leads to run-time undefined behavior.  We can't,
1851          therefore, simply error unless we can prove that all possible
1852          executions of the program must execute the code.  */
1853       warning ("function called through a non-compatible type");
1854
1855       /* We can, however, treat "undefined" any way we please.
1856          Call abort to encourage the user to fix the program.  */
1857       inform ("if this code is reached, the program will abort");
1858
1859       if (VOID_TYPE_P (return_type))
1860         return trap;
1861       else
1862         {
1863           tree rhs;
1864
1865           if (AGGREGATE_TYPE_P (return_type))
1866             rhs = build_compound_literal (return_type,
1867                                           build_constructor (return_type,
1868                                                              NULL_TREE));
1869           else
1870             rhs = fold (build1 (NOP_EXPR, return_type, integer_zero_node));
1871
1872           return build2 (COMPOUND_EXPR, return_type, trap, rhs);
1873         }
1874     }
1875
1876   /* Convert the parameters to the types declared in the
1877      function prototype, or apply default promotions.  */
1878
1879   coerced_params
1880     = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1881
1882   /* Check that the arguments to the function are valid.  */
1883
1884   check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
1885
1886   result = build3 (CALL_EXPR, TREE_TYPE (fntype),
1887                    function, coerced_params, NULL_TREE);
1888   TREE_SIDE_EFFECTS (result) = 1;
1889
1890   if (require_constant_value)
1891     {
1892       result = fold_initializer (result);
1893
1894       if (TREE_CONSTANT (result)
1895           && (name == NULL_TREE
1896               || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
1897         pedwarn_init ("initializer element is not constant");
1898     }
1899   else
1900     result = fold (result);
1901
1902   if (VOID_TYPE_P (TREE_TYPE (result)))
1903     return result;
1904   return require_complete_type (result);
1905 }
1906 \f
1907 /* Convert the argument expressions in the list VALUES
1908    to the types in the list TYPELIST.  The result is a list of converted
1909    argument expressions.
1910
1911    If TYPELIST is exhausted, or when an element has NULL as its type,
1912    perform the default conversions.
1913
1914    PARMLIST is the chain of parm decls for the function being called.
1915    It may be 0, if that info is not available.
1916    It is used only for generating error messages.
1917
1918    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
1919
1920    This is also where warnings about wrong number of args are generated.
1921
1922    Both VALUES and the returned value are chains of TREE_LIST nodes
1923    with the elements of the list in the TREE_VALUE slots of those nodes.  */
1924
1925 static tree
1926 convert_arguments (tree typelist, tree values, tree name, tree fundecl)
1927 {
1928   tree typetail, valtail;
1929   tree result = NULL;
1930   int parmnum;
1931
1932   /* Scan the given expressions and types, producing individual
1933      converted arguments and pushing them on RESULT in reverse order.  */
1934
1935   for (valtail = values, typetail = typelist, parmnum = 0;
1936        valtail;
1937        valtail = TREE_CHAIN (valtail), parmnum++)
1938     {
1939       tree type = typetail ? TREE_VALUE (typetail) : 0;
1940       tree val = TREE_VALUE (valtail);
1941
1942       if (type == void_type_node)
1943         {
1944           if (name)
1945             error ("too many arguments to function `%s'",
1946                    IDENTIFIER_POINTER (name));
1947           else
1948             error ("too many arguments to function");
1949           break;
1950         }
1951
1952       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1953       /* Do not use STRIP_NOPS here!  We do not want an enumerator with value 0
1954          to convert automatically to a pointer.  */
1955       if (TREE_CODE (val) == NON_LVALUE_EXPR)
1956         val = TREE_OPERAND (val, 0);
1957
1958       val = default_function_array_conversion (val);
1959
1960       val = require_complete_type (val);
1961
1962       if (type != 0)
1963         {
1964           /* Formal parm type is specified by a function prototype.  */
1965           tree parmval;
1966
1967           if (!COMPLETE_TYPE_P (type))
1968             {
1969               error ("type of formal parameter %d is incomplete", parmnum + 1);
1970               parmval = val;
1971             }
1972           else
1973             {
1974               /* Optionally warn about conversions that
1975                  differ from the default conversions.  */
1976               if (warn_conversion || warn_traditional)
1977                 {
1978                   unsigned int formal_prec = TYPE_PRECISION (type);
1979
1980                   if (INTEGRAL_TYPE_P (type)
1981                       && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1982                     warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1983                   if (INTEGRAL_TYPE_P (type)
1984                       && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1985                     warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1986                   else if (TREE_CODE (type) == COMPLEX_TYPE
1987                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1988                     warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1989                   else if (TREE_CODE (type) == REAL_TYPE
1990                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1991                     warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1992                   else if (TREE_CODE (type) == COMPLEX_TYPE
1993                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1994                     warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1995                   else if (TREE_CODE (type) == REAL_TYPE
1996                            && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1997                     warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1998                   /* ??? At some point, messages should be written about
1999                      conversions between complex types, but that's too messy
2000                      to do now.  */
2001                   else if (TREE_CODE (type) == REAL_TYPE
2002                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2003                     {
2004                       /* Warn if any argument is passed as `float',
2005                          since without a prototype it would be `double'.  */
2006                       if (formal_prec == TYPE_PRECISION (float_type_node))
2007                         warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
2008                     }
2009                   /* Detect integer changing in width or signedness.
2010                      These warnings are only activated with
2011                      -Wconversion, not with -Wtraditional.  */
2012                   else if (warn_conversion && INTEGRAL_TYPE_P (type)
2013                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2014                     {
2015                       tree would_have_been = default_conversion (val);
2016                       tree type1 = TREE_TYPE (would_have_been);
2017
2018                       if (TREE_CODE (type) == ENUMERAL_TYPE
2019                           && (TYPE_MAIN_VARIANT (type)
2020                               == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
2021                         /* No warning if function asks for enum
2022                            and the actual arg is that enum type.  */
2023                         ;
2024                       else if (formal_prec != TYPE_PRECISION (type1))
2025                         warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
2026                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
2027                         ;
2028                       /* Don't complain if the formal parameter type
2029                          is an enum, because we can't tell now whether
2030                          the value was an enum--even the same enum.  */
2031                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
2032                         ;
2033                       else if (TREE_CODE (val) == INTEGER_CST
2034                                && int_fits_type_p (val, type))
2035                         /* Change in signedness doesn't matter
2036                            if a constant value is unaffected.  */
2037                         ;
2038                       /* Likewise for a constant in a NOP_EXPR.  */
2039                       else if (TREE_CODE (val) == NOP_EXPR
2040                                && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
2041                                && int_fits_type_p (TREE_OPERAND (val, 0), type))
2042                         ;
2043                       /* If the value is extended from a narrower
2044                          unsigned type, it doesn't matter whether we
2045                          pass it as signed or unsigned; the value
2046                          certainly is the same either way.  */
2047                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
2048                                && TYPE_UNSIGNED (TREE_TYPE (val)))
2049                         ;
2050                       else if (TYPE_UNSIGNED (type))
2051                         warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
2052                       else
2053                         warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
2054                     }
2055                 }
2056
2057               parmval = convert_for_assignment (type, val,
2058                                                 (char *) 0, /* arg passing  */
2059                                                 fundecl, name, parmnum + 1);
2060
2061               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
2062                   && INTEGRAL_TYPE_P (type)
2063                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2064                 parmval = default_conversion (parmval);
2065             }
2066           result = tree_cons (NULL_TREE, parmval, result);
2067         }
2068       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
2069                && (TYPE_PRECISION (TREE_TYPE (val))
2070                    < TYPE_PRECISION (double_type_node)))
2071         /* Convert `float' to `double'.  */
2072         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
2073       else
2074         /* Convert `short' and `char' to full-size `int'.  */
2075         result = tree_cons (NULL_TREE, default_conversion (val), result);
2076
2077       if (typetail)
2078         typetail = TREE_CHAIN (typetail);
2079     }
2080
2081   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
2082     {
2083       if (name)
2084         error ("too few arguments to function `%s'",
2085                IDENTIFIER_POINTER (name));
2086       else
2087         error ("too few arguments to function");
2088     }
2089
2090   return nreverse (result);
2091 }
2092 \f
2093 /* This is the entry point used by the parser
2094    for binary operators in the input.
2095    In addition to constructing the expression,
2096    we check for operands that were written with other binary operators
2097    in a way that is likely to confuse the user.  */
2098
2099 struct c_expr
2100 parser_build_binary_op (enum tree_code code, struct c_expr arg1,
2101                         struct c_expr arg2)
2102 {
2103   struct c_expr result;
2104
2105   enum tree_code code1 = arg1.original_code;
2106   enum tree_code code2 = arg2.original_code;
2107
2108   result.value = build_binary_op (code, arg1.value, arg2.value, 1);
2109   result.original_code = code;
2110
2111   if (TREE_CODE (result.value) == ERROR_MARK)
2112     return result;
2113
2114   /* Check for cases such as x+y<<z which users are likely
2115      to misinterpret.  */
2116   if (warn_parentheses)
2117     {
2118       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
2119         {
2120           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2121               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2122             warning ("suggest parentheses around + or - inside shift");
2123         }
2124
2125       if (code == TRUTH_ORIF_EXPR)
2126         {
2127           if (code1 == TRUTH_ANDIF_EXPR
2128               || code2 == TRUTH_ANDIF_EXPR)
2129             warning ("suggest parentheses around && within ||");
2130         }
2131
2132       if (code == BIT_IOR_EXPR)
2133         {
2134           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
2135               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2136               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
2137               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2138             warning ("suggest parentheses around arithmetic in operand of |");
2139           /* Check cases like x|y==z */
2140           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2141             warning ("suggest parentheses around comparison in operand of |");
2142         }
2143
2144       if (code == BIT_XOR_EXPR)
2145         {
2146           if (code1 == BIT_AND_EXPR
2147               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2148               || code2 == BIT_AND_EXPR
2149               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2150             warning ("suggest parentheses around arithmetic in operand of ^");
2151           /* Check cases like x^y==z */
2152           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2153             warning ("suggest parentheses around comparison in operand of ^");
2154         }
2155
2156       if (code == BIT_AND_EXPR)
2157         {
2158           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2159               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2160             warning ("suggest parentheses around + or - in operand of &");
2161           /* Check cases like x&y==z */
2162           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2163             warning ("suggest parentheses around comparison in operand of &");
2164         }
2165       /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
2166       if (TREE_CODE_CLASS (code) == '<'
2167           && (TREE_CODE_CLASS (code1) == '<'
2168               || TREE_CODE_CLASS (code2) == '<'))
2169         warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2170
2171     }
2172
2173   unsigned_conversion_warning (result.value, arg1.value);
2174   unsigned_conversion_warning (result.value, arg2.value);
2175   overflow_warning (result.value);
2176
2177   return result;
2178 }
2179 \f
2180 /* Return a tree for the difference of pointers OP0 and OP1.
2181    The resulting tree has type int.  */
2182
2183 static tree
2184 pointer_diff (tree op0, tree op1)
2185 {
2186   tree restype = ptrdiff_type_node;
2187
2188   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2189   tree con0, con1, lit0, lit1;
2190   tree orig_op1 = op1;
2191
2192   if (pedantic || warn_pointer_arith)
2193     {
2194       if (TREE_CODE (target_type) == VOID_TYPE)
2195         pedwarn ("pointer of type `void *' used in subtraction");
2196       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2197         pedwarn ("pointer to a function used in subtraction");
2198     }
2199
2200   /* If the conversion to ptrdiff_type does anything like widening or
2201      converting a partial to an integral mode, we get a convert_expression
2202      that is in the way to do any simplifications.
2203      (fold-const.c doesn't know that the extra bits won't be needed.
2204      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2205      different mode in place.)
2206      So first try to find a common term here 'by hand'; we want to cover
2207      at least the cases that occur in legal static initializers.  */
2208   con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2209   con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2210
2211   if (TREE_CODE (con0) == PLUS_EXPR)
2212     {
2213       lit0 = TREE_OPERAND (con0, 1);
2214       con0 = TREE_OPERAND (con0, 0);
2215     }
2216   else
2217     lit0 = integer_zero_node;
2218
2219   if (TREE_CODE (con1) == PLUS_EXPR)
2220     {
2221       lit1 = TREE_OPERAND (con1, 1);
2222       con1 = TREE_OPERAND (con1, 0);
2223     }
2224   else
2225     lit1 = integer_zero_node;
2226
2227   if (operand_equal_p (con0, con1, 0))
2228     {
2229       op0 = lit0;
2230       op1 = lit1;
2231     }
2232
2233
2234   /* First do the subtraction as integers;
2235      then drop through to build the divide operator.
2236      Do not do default conversions on the minus operator
2237      in case restype is a short type.  */
2238
2239   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2240                          convert (restype, op1), 0);
2241   /* This generates an error if op1 is pointer to incomplete type.  */
2242   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2243     error ("arithmetic on pointer to an incomplete type");
2244
2245   /* This generates an error if op0 is pointer to incomplete type.  */
2246   op1 = c_size_in_bytes (target_type);
2247
2248   /* Divide by the size, in easiest possible way.  */
2249   return fold (build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)));
2250 }
2251 \f
2252 /* Construct and perhaps optimize a tree representation
2253    for a unary operation.  CODE, a tree_code, specifies the operation
2254    and XARG is the operand.
2255    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2256    the default promotions (such as from short to int).
2257    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2258    allows non-lvalues; this is only used to handle conversion of non-lvalue
2259    arrays to pointers in C99.  */
2260
2261 tree
2262 build_unary_op (enum tree_code code, tree xarg, int flag)
2263 {
2264   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2265   tree arg = xarg;
2266   tree argtype = 0;
2267   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2268   tree val;
2269   int noconvert = flag;
2270
2271   if (typecode == ERROR_MARK)
2272     return error_mark_node;
2273   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2274     typecode = INTEGER_TYPE;
2275
2276   switch (code)
2277     {
2278     case CONVERT_EXPR:
2279       /* This is used for unary plus, because a CONVERT_EXPR
2280          is enough to prevent anybody from looking inside for
2281          associativity, but won't generate any code.  */
2282       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2283             || typecode == COMPLEX_TYPE
2284             || typecode == VECTOR_TYPE))
2285         {
2286           error ("wrong type argument to unary plus");
2287           return error_mark_node;
2288         }
2289       else if (!noconvert)
2290         arg = default_conversion (arg);
2291       arg = non_lvalue (arg);
2292       break;
2293
2294     case NEGATE_EXPR:
2295       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2296             || typecode == COMPLEX_TYPE
2297             || typecode == VECTOR_TYPE))
2298         {
2299           error ("wrong type argument to unary minus");
2300           return error_mark_node;
2301         }
2302       else if (!noconvert)
2303         arg = default_conversion (arg);
2304       break;
2305
2306     case BIT_NOT_EXPR:
2307       if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2308         {
2309           if (!noconvert)
2310             arg = default_conversion (arg);
2311         }
2312       else if (typecode == COMPLEX_TYPE)
2313         {
2314           code = CONJ_EXPR;
2315           if (pedantic)
2316             pedwarn ("ISO C does not support `~' for complex conjugation");
2317           if (!noconvert)
2318             arg = default_conversion (arg);
2319         }
2320       else
2321         {
2322           error ("wrong type argument to bit-complement");
2323           return error_mark_node;
2324         }
2325       break;
2326
2327     case ABS_EXPR:
2328       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2329         {
2330           error ("wrong type argument to abs");
2331           return error_mark_node;
2332         }
2333       else if (!noconvert)
2334         arg = default_conversion (arg);
2335       break;
2336
2337     case CONJ_EXPR:
2338       /* Conjugating a real value is a no-op, but allow it anyway.  */
2339       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2340             || typecode == COMPLEX_TYPE))
2341         {
2342           error ("wrong type argument to conjugation");
2343           return error_mark_node;
2344         }
2345       else if (!noconvert)
2346         arg = default_conversion (arg);
2347       break;
2348
2349     case TRUTH_NOT_EXPR:
2350       if (typecode != INTEGER_TYPE
2351           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2352           && typecode != COMPLEX_TYPE
2353           /* These will convert to a pointer.  */
2354           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2355         {
2356           error ("wrong type argument to unary exclamation mark");
2357           return error_mark_node;
2358         }
2359       arg = lang_hooks.truthvalue_conversion (arg);
2360       return invert_truthvalue (arg);
2361
2362     case NOP_EXPR:
2363       break;
2364
2365     case REALPART_EXPR:
2366       if (TREE_CODE (arg) == COMPLEX_CST)
2367         return TREE_REALPART (arg);
2368       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2369         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2370       else
2371         return arg;
2372
2373     case IMAGPART_EXPR:
2374       if (TREE_CODE (arg) == COMPLEX_CST)
2375         return TREE_IMAGPART (arg);
2376       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2377         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2378       else
2379         return convert (TREE_TYPE (arg), integer_zero_node);
2380
2381     case PREINCREMENT_EXPR:
2382     case POSTINCREMENT_EXPR:
2383     case PREDECREMENT_EXPR:
2384     case POSTDECREMENT_EXPR:
2385
2386       /* Increment or decrement the real part of the value,
2387          and don't change the imaginary part.  */
2388       if (typecode == COMPLEX_TYPE)
2389         {
2390           tree real, imag;
2391
2392           if (pedantic)
2393             pedwarn ("ISO C does not support `++' and `--' on complex types");
2394
2395           arg = stabilize_reference (arg);
2396           real = build_unary_op (REALPART_EXPR, arg, 1);
2397           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2398           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
2399                          build_unary_op (code, real, 1), imag);
2400         }
2401
2402       /* Report invalid types.  */
2403
2404       if (typecode != POINTER_TYPE
2405           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2406         {
2407           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2408             error ("wrong type argument to increment");
2409           else
2410             error ("wrong type argument to decrement");
2411
2412           return error_mark_node;
2413         }
2414
2415       {
2416         tree inc;
2417         tree result_type = TREE_TYPE (arg);
2418
2419         arg = get_unwidened (arg, 0);
2420         argtype = TREE_TYPE (arg);
2421
2422         /* Compute the increment.  */
2423
2424         if (typecode == POINTER_TYPE)
2425           {
2426             /* If pointer target is an undefined struct,
2427                we just cannot know how to do the arithmetic.  */
2428             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2429               {
2430                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2431                   error ("increment of pointer to unknown structure");
2432                 else
2433                   error ("decrement of pointer to unknown structure");
2434               }
2435             else if ((pedantic || warn_pointer_arith)
2436                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2437                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2438               {
2439                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2440                   pedwarn ("wrong type argument to increment");
2441                 else
2442                   pedwarn ("wrong type argument to decrement");
2443               }
2444
2445             inc = c_size_in_bytes (TREE_TYPE (result_type));
2446           }
2447         else
2448           inc = integer_one_node;
2449
2450         inc = convert (argtype, inc);
2451
2452         /* Complain about anything else that is not a true lvalue.  */
2453         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2454                                     || code == POSTINCREMENT_EXPR)
2455                                    ? "invalid lvalue in increment"
2456                                    : "invalid lvalue in decrement")))
2457           return error_mark_node;
2458
2459         /* Report a read-only lvalue.  */
2460         if (TREE_READONLY (arg))
2461           readonly_error (arg,
2462                           ((code == PREINCREMENT_EXPR
2463                             || code == POSTINCREMENT_EXPR)
2464                            ? "increment" : "decrement"));
2465
2466         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2467           val = boolean_increment (code, arg);
2468         else
2469           val = build2 (code, TREE_TYPE (arg), arg, inc);
2470         TREE_SIDE_EFFECTS (val) = 1;
2471         val = convert (result_type, val);
2472         if (TREE_CODE (val) != code)
2473           TREE_NO_WARNING (val) = 1;
2474         return val;
2475       }
2476
2477     case ADDR_EXPR:
2478       /* Note that this operation never does default_conversion.  */
2479
2480       /* Let &* cancel out to simplify resulting code.  */
2481       if (TREE_CODE (arg) == INDIRECT_REF)
2482         {
2483           /* Don't let this be an lvalue.  */
2484           if (lvalue_p (TREE_OPERAND (arg, 0)))
2485             return non_lvalue (TREE_OPERAND (arg, 0));
2486           return TREE_OPERAND (arg, 0);
2487         }
2488
2489       /* For &x[y], return x+y */
2490       if (TREE_CODE (arg) == ARRAY_REF)
2491         {
2492           if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
2493             return error_mark_node;
2494           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2495                                   TREE_OPERAND (arg, 1), 1);
2496         }
2497
2498       /* Anything not already handled and not a true memory reference
2499          or a non-lvalue array is an error.  */
2500       else if (typecode != FUNCTION_TYPE && !flag
2501                && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
2502         return error_mark_node;
2503
2504       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
2505       argtype = TREE_TYPE (arg);
2506
2507       /* If the lvalue is const or volatile, merge that into the type
2508          to which the address will point.  Note that you can't get a
2509          restricted pointer by taking the address of something, so we
2510          only have to deal with `const' and `volatile' here.  */
2511       if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
2512           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
2513           argtype = c_build_type_variant (argtype,
2514                                           TREE_READONLY (arg),
2515                                           TREE_THIS_VOLATILE (arg));
2516
2517       argtype = build_pointer_type (argtype);
2518
2519       if (!c_mark_addressable (arg))
2520         return error_mark_node;
2521
2522       {
2523         tree addr;
2524
2525         if (TREE_CODE (arg) == COMPONENT_REF)
2526           {
2527             tree field = TREE_OPERAND (arg, 1);
2528
2529             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
2530
2531             if (DECL_C_BIT_FIELD (field))
2532               {
2533                 error ("attempt to take address of bit-field structure member `%s'",
2534                        IDENTIFIER_POINTER (DECL_NAME (field)));
2535                 return error_mark_node;
2536               }
2537
2538             addr = fold (build2 (PLUS_EXPR, argtype,
2539                                  convert (argtype, addr),
2540                                  convert (argtype, byte_position (field))));
2541           }
2542         else
2543           addr = build1 (code, argtype, arg);
2544
2545         if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
2546           TREE_INVARIANT (addr) = TREE_CONSTANT (addr) = 1;
2547
2548         return addr;
2549       }
2550
2551     default:
2552       break;
2553     }
2554
2555   if (argtype == 0)
2556     argtype = TREE_TYPE (arg);
2557   val = build1 (code, argtype, arg);
2558   return require_constant_value ? fold_initializer (val) : fold (val);
2559 }
2560
2561 /* Return nonzero if REF is an lvalue valid for this language.
2562    Lvalues can be assigned, unless their type has TYPE_READONLY.
2563    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
2564
2565 int
2566 lvalue_p (tree ref)
2567 {
2568   enum tree_code code = TREE_CODE (ref);
2569
2570   switch (code)
2571     {
2572     case REALPART_EXPR:
2573     case IMAGPART_EXPR:
2574     case COMPONENT_REF:
2575       return lvalue_p (TREE_OPERAND (ref, 0));
2576
2577     case COMPOUND_LITERAL_EXPR:
2578     case STRING_CST:
2579       return 1;
2580
2581     case INDIRECT_REF:
2582     case ARRAY_REF:
2583     case VAR_DECL:
2584     case PARM_DECL:
2585     case RESULT_DECL:
2586     case ERROR_MARK:
2587       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2588               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2589
2590     case BIND_EXPR:
2591       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2592
2593     default:
2594       return 0;
2595     }
2596 }
2597
2598 /* Return nonzero if REF is an lvalue valid for this language;
2599    otherwise, print an error message and return zero.  */
2600
2601 static int
2602 lvalue_or_else (tree ref, const char *msgid)
2603 {
2604   int win = lvalue_p (ref);
2605
2606   if (! win)
2607     error ("%s", msgid);
2608
2609   return win;
2610 }
2611
2612 \f
2613 /* Warn about storing in something that is `const'.  */
2614
2615 void
2616 readonly_error (tree arg, const char *msgid)
2617 {
2618   if (TREE_CODE (arg) == COMPONENT_REF)
2619     {
2620       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2621         readonly_error (TREE_OPERAND (arg, 0), msgid);
2622       else
2623         error ("%s of read-only member `%s'", _(msgid),
2624                IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
2625     }
2626   else if (TREE_CODE (arg) == VAR_DECL)
2627     error ("%s of read-only variable `%s'", _(msgid),
2628            IDENTIFIER_POINTER (DECL_NAME (arg)));
2629   else
2630     error ("%s of read-only location", _(msgid));
2631 }
2632 \f
2633 /* Mark EXP saying that we need to be able to take the
2634    address of it; it should not be allocated in a register.
2635    Returns true if successful.  */
2636
2637 bool
2638 c_mark_addressable (tree exp)
2639 {
2640   tree x = exp;
2641
2642   while (1)
2643     switch (TREE_CODE (x))
2644       {
2645       case COMPONENT_REF:
2646         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2647           {
2648             error ("cannot take address of bit-field `%s'",
2649                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
2650             return false;
2651           }
2652
2653         /* ... fall through ...  */
2654
2655       case ADDR_EXPR:
2656       case ARRAY_REF:
2657       case REALPART_EXPR:
2658       case IMAGPART_EXPR:
2659         x = TREE_OPERAND (x, 0);
2660         break;
2661
2662       case COMPOUND_LITERAL_EXPR:
2663       case CONSTRUCTOR:
2664         TREE_ADDRESSABLE (x) = 1;
2665         return true;
2666
2667       case VAR_DECL:
2668       case CONST_DECL:
2669       case PARM_DECL:
2670       case RESULT_DECL:
2671         if (C_DECL_REGISTER (x)
2672             && DECL_NONLOCAL (x))
2673           {
2674             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2675               {
2676                 error ("global register variable `%s' used in nested function",
2677                        IDENTIFIER_POINTER (DECL_NAME (x)));
2678                 return false;
2679               }
2680             pedwarn ("register variable `%s' used in nested function",
2681                      IDENTIFIER_POINTER (DECL_NAME (x)));
2682           }
2683         else if (C_DECL_REGISTER (x))
2684           {
2685             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2686               {
2687                 error ("address of global register variable `%s' requested",
2688                        IDENTIFIER_POINTER (DECL_NAME (x)));
2689                 return false;
2690               }
2691
2692             pedwarn ("address of register variable `%s' requested",
2693                      IDENTIFIER_POINTER (DECL_NAME (x)));
2694           }
2695
2696         /* drops in */
2697       case FUNCTION_DECL:
2698         TREE_ADDRESSABLE (x) = 1;
2699         /* drops out */
2700       default:
2701         return true;
2702     }
2703 }
2704 \f
2705 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
2706
2707 tree
2708 build_conditional_expr (tree ifexp, tree op1, tree op2)
2709 {
2710   tree type1;
2711   tree type2;
2712   enum tree_code code1;
2713   enum tree_code code2;
2714   tree result_type = NULL;
2715   tree orig_op1 = op1, orig_op2 = op2;
2716
2717   ifexp = lang_hooks.truthvalue_conversion (default_conversion (ifexp));
2718
2719   /* Promote both alternatives.  */
2720
2721   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2722     op1 = default_conversion (op1);
2723   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2724     op2 = default_conversion (op2);
2725
2726   if (TREE_CODE (ifexp) == ERROR_MARK
2727       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2728       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2729     return error_mark_node;
2730
2731   type1 = TREE_TYPE (op1);
2732   code1 = TREE_CODE (type1);
2733   type2 = TREE_TYPE (op2);
2734   code2 = TREE_CODE (type2);
2735
2736   /* C90 does not permit non-lvalue arrays in conditional expressions.
2737      In C99 they will be pointers by now.  */
2738   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
2739     {
2740       error ("non-lvalue array in conditional expression");
2741       return error_mark_node;
2742     }
2743
2744   /* Quickly detect the usual case where op1 and op2 have the same type
2745      after promotion.  */
2746   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2747     {
2748       if (type1 == type2)
2749         result_type = type1;
2750       else
2751         result_type = TYPE_MAIN_VARIANT (type1);
2752     }
2753   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2754             || code1 == COMPLEX_TYPE)
2755            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2756                || code2 == COMPLEX_TYPE))
2757     {
2758       result_type = common_type (type1, type2);
2759
2760       /* If -Wsign-compare, warn here if type1 and type2 have
2761          different signedness.  We'll promote the signed to unsigned
2762          and later code won't know it used to be different.
2763          Do this check on the original types, so that explicit casts
2764          will be considered, but default promotions won't.  */
2765       if (warn_sign_compare && !skip_evaluation)
2766         {
2767           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
2768           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
2769
2770           if (unsigned_op1 ^ unsigned_op2)
2771             {
2772               /* Do not warn if the result type is signed, since the
2773                  signed type will only be chosen if it can represent
2774                  all the values of the unsigned type.  */
2775               if (! TYPE_UNSIGNED (result_type))
2776                 /* OK */;
2777               /* Do not warn if the signed quantity is an unsuffixed
2778                  integer literal (or some static constant expression
2779                  involving such literals) and it is non-negative.  */
2780               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
2781                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
2782                 /* OK */;
2783               else
2784                 warning ("signed and unsigned type in conditional expression");
2785             }
2786         }
2787     }
2788   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2789     {
2790       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2791         pedwarn ("ISO C forbids conditional expr with only one void side");
2792       result_type = void_type_node;
2793     }
2794   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2795     {
2796       if (comp_target_types (type1, type2, 1))
2797         result_type = common_pointer_type (type1, type2);
2798       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2799                && TREE_CODE (orig_op1) != NOP_EXPR)
2800         result_type = qualify_type (type2, type1);
2801       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2802                && TREE_CODE (orig_op2) != NOP_EXPR)
2803         result_type = qualify_type (type1, type2);
2804       else if (VOID_TYPE_P (TREE_TYPE (type1)))
2805         {
2806           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2807             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2808           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2809                                                           TREE_TYPE (type2)));
2810         }
2811       else if (VOID_TYPE_P (TREE_TYPE (type2)))
2812         {
2813           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2814             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2815           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2816                                                           TREE_TYPE (type1)));
2817         }
2818       else
2819         {
2820           pedwarn ("pointer type mismatch in conditional expression");
2821           result_type = build_pointer_type (void_type_node);
2822         }
2823     }
2824   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2825     {
2826       if (! integer_zerop (op2))
2827         pedwarn ("pointer/integer type mismatch in conditional expression");
2828       else
2829         {
2830           op2 = null_pointer_node;
2831         }
2832       result_type = type1;
2833     }
2834   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
2835     {
2836       if (!integer_zerop (op1))
2837         pedwarn ("pointer/integer type mismatch in conditional expression");
2838       else
2839         {
2840           op1 = null_pointer_node;
2841         }
2842       result_type = type2;
2843     }
2844
2845   if (!result_type)
2846     {
2847       if (flag_cond_mismatch)
2848         result_type = void_type_node;
2849       else
2850         {
2851           error ("type mismatch in conditional expression");
2852           return error_mark_node;
2853         }
2854     }
2855
2856   /* Merge const and volatile flags of the incoming types.  */
2857   result_type
2858     = build_type_variant (result_type,
2859                           TREE_READONLY (op1) || TREE_READONLY (op2),
2860                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
2861
2862   if (result_type != TREE_TYPE (op1))
2863     op1 = convert_and_check (result_type, op1);
2864   if (result_type != TREE_TYPE (op2))
2865     op2 = convert_and_check (result_type, op2);
2866
2867   if (TREE_CODE (ifexp) == INTEGER_CST)
2868     return non_lvalue (integer_zerop (ifexp) ? op2 : op1);
2869
2870   return fold (build3 (COND_EXPR, result_type, ifexp, op1, op2));
2871 }
2872 \f
2873 /* Return a compound expression that performs two expressions and
2874    returns the value of the second of them.  */
2875
2876 tree
2877 build_compound_expr (tree expr1, tree expr2)
2878 {
2879   /* Convert arrays and functions to pointers.  */
2880   expr2 = default_function_array_conversion (expr2);
2881
2882   /* Don't let (0, 0) be null pointer constant.  */
2883   if (integer_zerop (expr2))
2884     expr2 = non_lvalue (expr2);
2885
2886   if (! TREE_SIDE_EFFECTS (expr1))
2887     {
2888       /* The left-hand operand of a comma expression is like an expression
2889          statement: with -Wextra or -Wunused, we should warn if it doesn't have
2890          any side-effects, unless it was explicitly cast to (void).  */
2891       if (warn_unused_value
2892            && ! (TREE_CODE (expr1) == CONVERT_EXPR
2893                 && VOID_TYPE_P (TREE_TYPE (expr1))))
2894         warning ("left-hand operand of comma expression has no effect");
2895     }
2896
2897   /* With -Wunused, we should also warn if the left-hand operand does have
2898      side-effects, but computes a value which is not used.  For example, in
2899      `foo() + bar(), baz()' the result of the `+' operator is not used,
2900      so we should issue a warning.  */
2901   else if (warn_unused_value)
2902     warn_if_unused_value (expr1, input_location);
2903
2904   return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
2905 }
2906
2907 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
2908
2909 tree
2910 build_c_cast (tree type, tree expr)
2911 {
2912   tree value = expr;
2913
2914   if (type == error_mark_node || expr == error_mark_node)
2915     return error_mark_node;
2916
2917   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
2918      only in <protocol> qualifications.  But when constructing cast expressions,
2919      the protocols do matter and must be kept around.  */
2920   if (!c_dialect_objc () || !objc_is_object_ptr (type))
2921     type = TYPE_MAIN_VARIANT (type);
2922
2923   if (TREE_CODE (type) == ARRAY_TYPE)
2924     {
2925       error ("cast specifies array type");
2926       return error_mark_node;
2927     }
2928
2929   if (TREE_CODE (type) == FUNCTION_TYPE)
2930     {
2931       error ("cast specifies function type");
2932       return error_mark_node;
2933     }
2934
2935   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
2936     {
2937       if (pedantic)
2938         {
2939           if (TREE_CODE (type) == RECORD_TYPE
2940               || TREE_CODE (type) == UNION_TYPE)
2941             pedwarn ("ISO C forbids casting nonscalar to the same type");
2942         }
2943     }
2944   else if (TREE_CODE (type) == UNION_TYPE)
2945     {
2946       tree field;
2947       value = default_function_array_conversion (value);
2948
2949       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2950         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
2951                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
2952           break;
2953
2954       if (field)
2955         {
2956           tree t;
2957
2958           if (pedantic)
2959             pedwarn ("ISO C forbids casts to union type");
2960           t = digest_init (type,
2961                            build_constructor (type,
2962                                               build_tree_list (field, value)),
2963                            true, 0);
2964           TREE_CONSTANT (t) = TREE_CONSTANT (value);
2965           TREE_INVARIANT (t) = TREE_INVARIANT (value);
2966           return t;
2967         }
2968       error ("cast to union type from type not present in union");
2969       return error_mark_node;
2970     }
2971   else
2972     {
2973       tree otype, ovalue;
2974
2975       /* If casting to void, avoid the error that would come
2976          from default_conversion in the case of a non-lvalue array.  */
2977       if (type == void_type_node)
2978         return build1 (CONVERT_EXPR, type, value);
2979
2980       /* Convert functions and arrays to pointers,
2981          but don't convert any other types.  */
2982       value = default_function_array_conversion (value);
2983       otype = TREE_TYPE (value);
2984
2985       /* Optionally warn about potentially worrisome casts.  */
2986
2987       if (warn_cast_qual
2988           && TREE_CODE (type) == POINTER_TYPE
2989           && TREE_CODE (otype) == POINTER_TYPE)
2990         {
2991           tree in_type = type;
2992           tree in_otype = otype;
2993           int added = 0;
2994           int discarded = 0;
2995
2996           /* Check that the qualifiers on IN_TYPE are a superset of
2997              the qualifiers of IN_OTYPE.  The outermost level of
2998              POINTER_TYPE nodes is uninteresting and we stop as soon
2999              as we hit a non-POINTER_TYPE node on either type.  */
3000           do
3001             {
3002               in_otype = TREE_TYPE (in_otype);
3003               in_type = TREE_TYPE (in_type);
3004
3005               /* GNU C allows cv-qualified function types.  'const'
3006                  means the function is very pure, 'volatile' means it
3007                  can't return.  We need to warn when such qualifiers
3008                  are added, not when they're taken away.  */
3009               if (TREE_CODE (in_otype) == FUNCTION_TYPE
3010                   && TREE_CODE (in_type) == FUNCTION_TYPE)
3011                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3012               else
3013                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3014             }
3015           while (TREE_CODE (in_type) == POINTER_TYPE
3016                  && TREE_CODE (in_otype) == POINTER_TYPE);
3017
3018           if (added)
3019             warning ("cast adds new qualifiers to function type");
3020
3021           if (discarded)
3022             /* There are qualifiers present in IN_OTYPE that are not
3023                present in IN_TYPE.  */
3024             warning ("cast discards qualifiers from pointer target type");
3025         }
3026
3027       /* Warn about possible alignment problems.  */
3028       if (STRICT_ALIGNMENT && warn_cast_align
3029           && TREE_CODE (type) == POINTER_TYPE
3030           && TREE_CODE (otype) == POINTER_TYPE
3031           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3032           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3033           /* Don't warn about opaque types, where the actual alignment
3034              restriction is unknown.  */
3035           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3036                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3037                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3038           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3039         warning ("cast increases required alignment of target type");
3040
3041       if (TREE_CODE (type) == INTEGER_TYPE
3042           && TREE_CODE (otype) == POINTER_TYPE
3043           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3044           && !TREE_CONSTANT (value))
3045         warning ("cast from pointer to integer of different size");
3046
3047       if (warn_bad_function_cast
3048           && TREE_CODE (value) == CALL_EXPR
3049           && TREE_CODE (type) != TREE_CODE (otype))
3050         warning ("cast does not match function type");
3051
3052       if (TREE_CODE (type) == POINTER_TYPE
3053           && TREE_CODE (otype) == INTEGER_TYPE
3054           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3055           /* Don't warn about converting any constant.  */
3056           && !TREE_CONSTANT (value))
3057         warning ("cast to pointer from integer of different size");
3058
3059       if (TREE_CODE (type) == POINTER_TYPE
3060           && TREE_CODE (otype) == POINTER_TYPE
3061           && TREE_CODE (expr) == ADDR_EXPR
3062           && DECL_P (TREE_OPERAND (expr, 0))
3063           && flag_strict_aliasing && warn_strict_aliasing
3064           && !VOID_TYPE_P (TREE_TYPE (type)))
3065         {
3066           /* Casting the address of a decl to non void pointer. Warn
3067              if the cast breaks type based aliasing.  */
3068           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3069             warning ("type-punning to incomplete type might break strict-aliasing rules");
3070           else
3071             {
3072               HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
3073               HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
3074
3075               if (!alias_sets_conflict_p (set1, set2))
3076                 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3077               else if (warn_strict_aliasing > 1
3078                        && !alias_sets_might_conflict_p (set1, set2))
3079                 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3080             }
3081         }
3082
3083       /* If pedantic, warn for conversions between function and object
3084          pointer types, except for converting a null pointer constant
3085          to function pointer type.  */
3086       if (pedantic
3087           && TREE_CODE (type) == POINTER_TYPE
3088           && TREE_CODE (otype) == POINTER_TYPE
3089           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3090           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3091         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3092
3093       if (pedantic
3094           && TREE_CODE (type) == POINTER_TYPE
3095           && TREE_CODE (otype) == POINTER_TYPE
3096           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3097           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3098           && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3099                && TREE_CODE (expr) != NOP_EXPR))
3100         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3101
3102       ovalue = value;
3103       /* Replace a nonvolatile const static variable with its value.  */
3104       if (optimize && TREE_CODE (value) == VAR_DECL)
3105         value = decl_constant_value (value);
3106       value = convert (type, value);
3107
3108       /* Ignore any integer overflow caused by the cast.  */
3109       if (TREE_CODE (value) == INTEGER_CST)
3110         {
3111           if (EXPR_P (ovalue))
3112             TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3113           else
3114             TREE_OVERFLOW (value) = 0;
3115
3116           if (TREE_CODE_CLASS (TREE_CODE (ovalue)) == 'c')
3117             TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3118         }
3119     }
3120
3121   /* Don't let (void *) (FOO *) 0 be a null pointer constant.  */
3122   if (TREE_CODE (value) == INTEGER_CST
3123       && TREE_CODE (expr) == INTEGER_CST
3124       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3125     value = non_lvalue (value);
3126
3127   /* Don't let a cast be an lvalue.  */
3128   if (value == expr)
3129     value = non_lvalue (value);
3130
3131   return value;
3132 }
3133
3134 /* Interpret a cast of expression EXPR to type TYPE.  */
3135 tree
3136 c_cast_expr (tree type, tree expr)
3137 {
3138   int saved_wsp = warn_strict_prototypes;
3139
3140   /* This avoids warnings about unprototyped casts on
3141      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3142   if (TREE_CODE (expr) == INTEGER_CST)
3143     warn_strict_prototypes = 0;
3144   type = groktypename (type);
3145   warn_strict_prototypes = saved_wsp;
3146
3147   return build_c_cast (type, expr);
3148 }
3149
3150 \f
3151 /* Build an assignment expression of lvalue LHS from value RHS.
3152    MODIFYCODE is the code for a binary operator that we use
3153    to combine the old value of LHS with RHS to get the new value.
3154    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3155
3156 tree
3157 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3158 {
3159   tree result;
3160   tree newrhs;
3161   tree lhstype = TREE_TYPE (lhs);
3162   tree olhstype = lhstype;
3163
3164   /* Types that aren't fully specified cannot be used in assignments.  */
3165   lhs = require_complete_type (lhs);
3166
3167   /* Avoid duplicate error messages from operands that had errors.  */
3168   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3169     return error_mark_node;
3170
3171   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3172   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3173      whose value is 0 to count as a null pointer constant.  */
3174   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3175     rhs = TREE_OPERAND (rhs, 0);
3176
3177   newrhs = rhs;
3178
3179   /* If a binary op has been requested, combine the old LHS value with the RHS
3180      producing the value we should actually store into the LHS.  */
3181
3182   if (modifycode != NOP_EXPR)
3183     {
3184       lhs = stabilize_reference (lhs);
3185       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3186     }
3187
3188   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3189     return error_mark_node;
3190
3191   /* Warn about storing in something that is `const'.  */
3192
3193   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3194       || ((TREE_CODE (lhstype) == RECORD_TYPE
3195            || TREE_CODE (lhstype) == UNION_TYPE)
3196           && C_TYPE_FIELDS_READONLY (lhstype)))
3197     readonly_error (lhs, "assignment");
3198
3199   /* If storing into a structure or union member,
3200      it has probably been given type `int'.
3201      Compute the type that would go with
3202      the actual amount of storage the member occupies.  */
3203
3204   if (TREE_CODE (lhs) == COMPONENT_REF
3205       && (TREE_CODE (lhstype) == INTEGER_TYPE
3206           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3207           || TREE_CODE (lhstype) == REAL_TYPE
3208           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3209     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3210
3211   /* If storing in a field that is in actuality a short or narrower than one,
3212      we must store in the field in its actual type.  */
3213
3214   if (lhstype != TREE_TYPE (lhs))
3215     {
3216       lhs = copy_node (lhs);
3217       TREE_TYPE (lhs) = lhstype;
3218     }
3219
3220   /* Convert new value to destination type.  */
3221
3222   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3223                                    NULL_TREE, NULL_TREE, 0);
3224   if (TREE_CODE (newrhs) == ERROR_MARK)
3225     return error_mark_node;
3226
3227   /* Scan operands */
3228
3229   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
3230   TREE_SIDE_EFFECTS (result) = 1;
3231
3232   /* If we got the LHS in a different type for storing in,
3233      convert the result back to the nominal type of LHS
3234      so that the value we return always has the same type
3235      as the LHS argument.  */
3236
3237   if (olhstype == TREE_TYPE (result))
3238     return result;
3239   return convert_for_assignment (olhstype, result, _("assignment"),
3240                                  NULL_TREE, NULL_TREE, 0);
3241 }
3242 \f
3243 /* Convert value RHS to type TYPE as preparation for an assignment
3244    to an lvalue of type TYPE.
3245    The real work of conversion is done by `convert'.
3246    The purpose of this function is to generate error messages
3247    for assignments that are not allowed in C.
3248    ERRTYPE is a string to use in error messages:
3249    "assignment", "return", etc.  If it is null, this is parameter passing
3250    for a function call (and different error messages are output).
3251
3252    FUNNAME is the name of the function being called,
3253    as an IDENTIFIER_NODE, or null.
3254    PARMNUM is the number of the argument, for printing in error messages.  */
3255
3256 static tree
3257 convert_for_assignment (tree type, tree rhs, const char *errtype,
3258                         tree fundecl, tree funname, int parmnum)
3259 {
3260   enum tree_code codel = TREE_CODE (type);
3261   tree rhstype;
3262   enum tree_code coder;
3263
3264   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3265   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3266      whose value is 0 to count as a null pointer constant.  */
3267   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3268     rhs = TREE_OPERAND (rhs, 0);
3269
3270   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3271       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3272     rhs = default_conversion (rhs);
3273   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3274     rhs = decl_constant_value_for_broken_optimization (rhs);
3275
3276   rhstype = TREE_TYPE (rhs);
3277   coder = TREE_CODE (rhstype);
3278
3279   if (coder == ERROR_MARK)
3280     return error_mark_node;
3281
3282   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3283     {
3284       overflow_warning (rhs);
3285       /* Check for Objective-C protocols.  This will automatically
3286          issue a warning if there are protocol violations.  No need to
3287          use the return value.  */
3288       if (c_dialect_objc ())
3289         objc_comptypes (type, rhstype, 0);
3290       return rhs;
3291     }
3292
3293   if (coder == VOID_TYPE)
3294     {
3295       error ("void value not ignored as it ought to be");
3296       return error_mark_node;
3297     }
3298   /* A type converts to a reference to it.
3299      This code doesn't fully support references, it's just for the
3300      special case of va_start and va_copy.  */
3301   if (codel == REFERENCE_TYPE
3302       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3303     {
3304       if (!lvalue_p (rhs))
3305         {
3306           error ("cannot pass rvalue to reference parameter");
3307           return error_mark_node;
3308         }
3309       if (!c_mark_addressable (rhs))
3310         return error_mark_node;
3311       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3312
3313       /* We already know that these two types are compatible, but they
3314          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3315          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3316          likely to be va_list, a typedef to __builtin_va_list, which
3317          is different enough that it will cause problems later.  */
3318       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3319         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3320
3321       rhs = build1 (NOP_EXPR, type, rhs);
3322       return rhs;
3323     }
3324   /* Some types can interconvert without explicit casts.  */
3325   else if (codel == VECTOR_TYPE
3326            && vector_types_convertible_p (type, TREE_TYPE (rhs)))
3327     return convert (type, rhs);
3328   /* Arithmetic types all interconvert, and enum is treated like int.  */
3329   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3330             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3331             || codel == BOOLEAN_TYPE)
3332            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3333                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3334                || coder == BOOLEAN_TYPE))
3335     return convert_and_check (type, rhs);
3336
3337   /* Conversion to a transparent union from its member types.
3338      This applies only to function arguments.  */
3339   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
3340     {
3341       tree memb_types;
3342       tree marginal_memb_type = 0;
3343
3344       for (memb_types = TYPE_FIELDS (type); memb_types;
3345            memb_types = TREE_CHAIN (memb_types))
3346         {
3347           tree memb_type = TREE_TYPE (memb_types);
3348
3349           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3350                          TYPE_MAIN_VARIANT (rhstype)))
3351             break;
3352
3353           if (TREE_CODE (memb_type) != POINTER_TYPE)
3354             continue;
3355
3356           if (coder == POINTER_TYPE)
3357             {
3358               tree ttl = TREE_TYPE (memb_type);
3359               tree ttr = TREE_TYPE (rhstype);
3360
3361               /* Any non-function converts to a [const][volatile] void *
3362                  and vice versa; otherwise, targets must be the same.
3363                  Meanwhile, the lhs target must have all the qualifiers of
3364                  the rhs.  */
3365               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3366                   || comp_target_types (memb_type, rhstype, 0))
3367                 {
3368                   /* If this type won't generate any warnings, use it.  */
3369                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3370                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3371                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3372                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3373                              == TYPE_QUALS (ttr))
3374                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3375                              == TYPE_QUALS (ttl))))
3376                     break;
3377
3378                   /* Keep looking for a better type, but remember this one.  */
3379                   if (! marginal_memb_type)
3380                     marginal_memb_type = memb_type;
3381                 }
3382             }
3383
3384           /* Can convert integer zero to any pointer type.  */
3385           if (integer_zerop (rhs)
3386               || (TREE_CODE (rhs) == NOP_EXPR
3387                   && integer_zerop (TREE_OPERAND (rhs, 0))))
3388             {
3389               rhs = null_pointer_node;
3390               break;
3391             }
3392         }
3393
3394       if (memb_types || marginal_memb_type)
3395         {
3396           if (! memb_types)
3397             {
3398               /* We have only a marginally acceptable member type;
3399                  it needs a warning.  */
3400               tree ttl = TREE_TYPE (marginal_memb_type);
3401               tree ttr = TREE_TYPE (rhstype);
3402
3403               /* Const and volatile mean something different for function
3404                  types, so the usual warnings are not appropriate.  */
3405               if (TREE_CODE (ttr) == FUNCTION_TYPE
3406                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3407                 {
3408                   /* Because const and volatile on functions are
3409                      restrictions that say the function will not do
3410                      certain things, it is okay to use a const or volatile
3411                      function where an ordinary one is wanted, but not
3412                      vice-versa.  */
3413                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3414                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
3415                                          errtype, funname, parmnum);
3416                 }
3417               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3418                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3419                                      errtype, funname,
3420                                      parmnum);
3421             }
3422
3423           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
3424             pedwarn ("ISO C prohibits argument conversion to union type");
3425
3426           return build1 (NOP_EXPR, type, rhs);
3427         }
3428     }
3429
3430   /* Conversions among pointers */
3431   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3432            && (coder == codel))
3433     {
3434       tree ttl = TREE_TYPE (type);
3435       tree ttr = TREE_TYPE (rhstype);
3436       bool is_opaque_pointer;
3437       int target_cmp = 0;   /* Cache comp_target_types () result.  */
3438
3439       /* Opaque pointers are treated like void pointers.  */
3440       is_opaque_pointer = (targetm.vector_opaque_p (type)
3441                            || targetm.vector_opaque_p (rhstype))
3442         && TREE_CODE (ttl) == VECTOR_TYPE
3443         && TREE_CODE (ttr) == VECTOR_TYPE;
3444
3445       /* Any non-function converts to a [const][volatile] void *
3446          and vice versa; otherwise, targets must be the same.
3447          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3448       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3449           || (target_cmp = comp_target_types (type, rhstype, 0))
3450           || is_opaque_pointer
3451           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3452               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3453         {
3454           if (pedantic
3455               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3456                   ||
3457                   (VOID_TYPE_P (ttr)
3458                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3459                       which are not ANSI null ptr constants.  */
3460                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3461                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3462             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
3463                                  errtype, funname, parmnum);
3464           /* Const and volatile mean something different for function types,
3465              so the usual warnings are not appropriate.  */
3466           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3467                    && TREE_CODE (ttl) != FUNCTION_TYPE)
3468             {
3469               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3470                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3471                                      errtype, funname, parmnum);
3472               /* If this is not a case of ignoring a mismatch in signedness,
3473                  no warning.  */
3474               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3475                        || target_cmp)
3476                 ;
3477               /* If there is a mismatch, do warn.  */
3478               else
3479                 warn_for_assignment ("pointer targets in %s differ in signedness",
3480                                      errtype, funname, parmnum);
3481             }
3482           else if (TREE_CODE (ttl) == FUNCTION_TYPE
3483                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3484             {
3485               /* Because const and volatile on functions are restrictions
3486                  that say the function will not do certain things,
3487                  it is okay to use a const or volatile function
3488                  where an ordinary one is wanted, but not vice-versa.  */
3489               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3490                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
3491                                      errtype, funname, parmnum);
3492             }
3493         }
3494       else
3495         warn_for_assignment ("%s from incompatible pointer type",
3496                              errtype, funname, parmnum);
3497       return convert (type, rhs);
3498     }
3499   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3500     {
3501       error ("invalid use of non-lvalue array");
3502       return error_mark_node;
3503     }
3504   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3505     {
3506       /* An explicit constant 0 can convert to a pointer,
3507          or one that results from arithmetic, even including
3508          a cast to integer type.  */
3509       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3510           &&
3511           ! (TREE_CODE (rhs) == NOP_EXPR
3512              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3513              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3514              && integer_zerop (TREE_OPERAND (rhs, 0))))
3515           warn_for_assignment ("%s makes pointer from integer without a cast",
3516                                errtype, funname, parmnum);
3517
3518       return convert (type, rhs);
3519     }
3520   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3521     {
3522       warn_for_assignment ("%s makes integer from pointer without a cast",
3523                            errtype, funname, parmnum);
3524       return convert (type, rhs);
3525     }
3526   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3527     return convert (type, rhs);
3528
3529   if (!errtype)
3530     {
3531       if (funname)
3532         {
3533           tree selector = objc_message_selector ();
3534
3535           if (selector && parmnum > 2)
3536             error ("incompatible type for argument %d of `%s'",
3537                    parmnum - 2, IDENTIFIER_POINTER (selector));
3538           else
3539             error ("incompatible type for argument %d of `%s'",
3540                    parmnum, IDENTIFIER_POINTER (funname));
3541         }
3542       else
3543         error ("incompatible type for argument %d of indirect function call",
3544                parmnum);
3545     }
3546   else
3547     error ("incompatible types in %s", errtype);
3548
3549   return error_mark_node;
3550 }
3551
3552 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
3553    is used for error and waring reporting and indicates which argument
3554    is being processed.  */
3555
3556 tree
3557 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3558 {
3559   tree ret, type;
3560
3561   /* If FN was prototyped, the value has been converted already
3562      in convert_arguments.  */
3563   if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3564     return value;
3565
3566   type = TREE_TYPE (parm);
3567   ret = convert_for_assignment (type, value,
3568                                 (char *) 0 /* arg passing  */, fn,
3569                                 DECL_NAME (fn), argnum);
3570   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3571       && INTEGRAL_TYPE_P (type)
3572       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3573     ret = default_conversion (ret);
3574   return ret;
3575 }
3576
3577 /* Print a warning using MSGID.
3578    It gets OPNAME as its one parameter.
3579    if OPNAME is null and ARGNUM is 0, it is replaced by "passing arg of `FUNCTION'".
3580    Otherwise if OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
3581    FUNCTION and ARGNUM are handled specially if we are building an
3582    Objective-C selector.  */
3583
3584 static void
3585 warn_for_assignment (const char *msgid, const char *opname, tree function,
3586                      int argnum)
3587 {
3588   if (opname == 0)
3589     {
3590       tree selector = objc_message_selector ();
3591       char * new_opname;
3592
3593       if (selector && argnum > 2)
3594         {
3595           function = selector;
3596           argnum -= 2;
3597         }
3598       if (argnum == 0)
3599         {
3600           if (function)
3601             {
3602               /* Function name is known; supply it.  */
3603               const char *const argstring = _("passing arg of `%s'");
3604               new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
3605                                    + strlen (argstring) + 1 + 1);
3606               sprintf (new_opname, argstring,
3607                        IDENTIFIER_POINTER (function));
3608             }
3609           else
3610             {
3611               /* Function name unknown (call through ptr).  */
3612               const char *const argnofun = _("passing arg of pointer to function");
3613               new_opname = (char *) alloca (strlen (argnofun) + 1 + 1);
3614               sprintf (new_opname, argnofun);
3615             }
3616         }
3617       else if (function)
3618         {
3619           /* Function name is known; supply it.  */
3620           const char *const argstring = _("passing arg %d of `%s'");
3621           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
3622                                + strlen (argstring) + 1 + 25 /*%d*/ + 1);
3623           sprintf (new_opname, argstring, argnum,
3624                    IDENTIFIER_POINTER (function));
3625         }
3626       else
3627         {
3628           /* Function name unknown (call through ptr); just give arg number.  */
3629           const char *const argnofun = _("passing arg %d of pointer to function");
3630           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
3631           sprintf (new_opname, argnofun, argnum);
3632         }
3633       opname = new_opname;
3634     }
3635   pedwarn (msgid, opname);
3636 }
3637 \f
3638 /* If VALUE is a compound expr all of whose expressions are constant, then
3639    return its value.  Otherwise, return error_mark_node.
3640
3641    This is for handling COMPOUND_EXPRs as initializer elements
3642    which is allowed with a warning when -pedantic is specified.  */
3643
3644 static tree
3645 valid_compound_expr_initializer (tree value, tree endtype)
3646 {
3647   if (TREE_CODE (value) == COMPOUND_EXPR)
3648     {
3649       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3650           == error_mark_node)
3651         return error_mark_node;
3652       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3653                                               endtype);
3654     }
3655   else if (! TREE_CONSTANT (value)
3656            && ! initializer_constant_valid_p (value, endtype))
3657     return error_mark_node;
3658   else
3659     return value;
3660 }
3661 \f
3662 /* Perform appropriate conversions on the initial value of a variable,
3663    store it in the declaration DECL,
3664    and print any error messages that are appropriate.
3665    If the init is invalid, store an ERROR_MARK.  */
3666
3667 void
3668 store_init_value (tree decl, tree init)
3669 {
3670   tree value, type;
3671
3672   /* If variable's type was invalidly declared, just ignore it.  */
3673
3674   type = TREE_TYPE (decl);
3675   if (TREE_CODE (type) == ERROR_MARK)
3676     return;
3677
3678   /* Digest the specified initializer into an expression.  */
3679
3680   value = digest_init (type, init, true, TREE_STATIC (decl));
3681
3682   /* Store the expression if valid; else report error.  */
3683
3684   if (warn_traditional && !in_system_header
3685       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
3686     warning ("traditional C rejects automatic aggregate initialization");
3687
3688   DECL_INITIAL (decl) = value;
3689
3690   /* ANSI wants warnings about out-of-range constant initializers.  */
3691   STRIP_TYPE_NOPS (value);
3692   constant_expression_warning (value);
3693
3694   /* Check if we need to set array size from compound literal size.  */
3695   if (TREE_CODE (type) == ARRAY_TYPE
3696       && TYPE_DOMAIN (type) == 0
3697       && value != error_mark_node)
3698     {
3699       tree inside_init = init;
3700
3701       if (TREE_CODE (init) == NON_LVALUE_EXPR)
3702         inside_init = TREE_OPERAND (init, 0);
3703       inside_init = fold (inside_init);
3704
3705       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3706         {
3707           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3708
3709           if (TYPE_DOMAIN (TREE_TYPE (decl)))
3710             {
3711               /* For int foo[] = (int [3]){1}; we need to set array size
3712                  now since later on array initializer will be just the
3713                  brace enclosed list of the compound literal.  */
3714               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3715               layout_type (type);
3716               layout_decl (decl, 0);
3717             }
3718         }
3719     }
3720 }
3721 \f
3722 /* Methods for storing and printing names for error messages.  */
3723
3724 /* Implement a spelling stack that allows components of a name to be pushed
3725    and popped.  Each element on the stack is this structure.  */
3726
3727 struct spelling
3728 {
3729   int kind;
3730   union
3731     {
3732       int i;
3733       const char *s;
3734     } u;
3735 };
3736
3737 #define SPELLING_STRING 1
3738 #define SPELLING_MEMBER 2
3739 #define SPELLING_BOUNDS 3
3740
3741 static struct spelling *spelling;       /* Next stack element (unused).  */
3742 static struct spelling *spelling_base;  /* Spelling stack base.  */
3743 static int spelling_size;               /* Size of the spelling stack.  */
3744
3745 /* Macros to save and restore the spelling stack around push_... functions.
3746    Alternative to SAVE_SPELLING_STACK.  */
3747
3748 #define SPELLING_DEPTH() (spelling - spelling_base)
3749 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3750
3751 /* Push an element on the spelling stack with type KIND and assign VALUE
3752    to MEMBER.  */
3753
3754 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
3755 {                                                                       \
3756   int depth = SPELLING_DEPTH ();                                        \
3757                                                                         \
3758   if (depth >= spelling_size)                                           \
3759     {                                                                   \
3760       spelling_size += 10;                                              \
3761       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
3762                                   spelling_size);                       \
3763       RESTORE_SPELLING_DEPTH (depth);                                   \
3764     }                                                                   \
3765                                                                         \
3766   spelling->kind = (KIND);                                              \
3767   spelling->MEMBER = (VALUE);                                           \
3768   spelling++;                                                           \
3769 }
3770
3771 /* Push STRING on the stack.  Printed literally.  */
3772
3773 static void
3774 push_string (const char *string)
3775 {
3776   PUSH_SPELLING (SPELLING_STRING, string, u.s);
3777 }
3778
3779 /* Push a member name on the stack.  Printed as '.' STRING.  */
3780
3781 static void
3782 push_member_name (tree decl)
3783 {
3784   const char *const string
3785     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3786   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3787 }
3788
3789 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
3790
3791 static void
3792 push_array_bounds (int bounds)
3793 {
3794   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
3795 }
3796
3797 /* Compute the maximum size in bytes of the printed spelling.  */
3798
3799 static int
3800 spelling_length (void)
3801 {
3802   int size = 0;
3803   struct spelling *p;
3804
3805   for (p = spelling_base; p < spelling; p++)
3806     {
3807       if (p->kind == SPELLING_BOUNDS)
3808         size += 25;
3809       else
3810         size += strlen (p->u.s) + 1;
3811     }
3812
3813   return size;
3814 }
3815
3816 /* Print the spelling to BUFFER and return it.  */
3817
3818 static char *
3819 print_spelling (char *buffer)
3820 {
3821   char *d = buffer;
3822   struct spelling *p;
3823
3824   for (p = spelling_base; p < spelling; p++)
3825     if (p->kind == SPELLING_BOUNDS)
3826       {
3827         sprintf (d, "[%d]", p->u.i);
3828         d += strlen (d);
3829       }
3830     else
3831       {
3832         const char *s;
3833         if (p->kind == SPELLING_MEMBER)
3834           *d++ = '.';
3835         for (s = p->u.s; (*d = *s++); d++)
3836           ;
3837       }
3838   *d++ = '\0';
3839   return buffer;
3840 }
3841
3842 /* Issue an error message for a bad initializer component.
3843    MSGID identifies the message.
3844    The component name is taken from the spelling stack.  */
3845
3846 void
3847 error_init (const char *msgid)
3848 {
3849   char *ofwhat;
3850
3851   error ("%s", _(msgid));
3852   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3853   if (*ofwhat)
3854     error ("(near initialization for `%s')", ofwhat);
3855 }
3856
3857 /* Issue a pedantic warning for a bad initializer component.
3858    MSGID identifies the message.
3859    The component name is taken from the spelling stack.  */
3860
3861 void
3862 pedwarn_init (const char *msgid)
3863 {
3864   char *ofwhat;
3865
3866   pedwarn ("%s", _(msgid));
3867   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3868   if (*ofwhat)
3869     pedwarn ("(near initialization for `%s')", ofwhat);
3870 }
3871
3872 /* Issue a warning for a bad initializer component.
3873    MSGID identifies the message.
3874    The component name is taken from the spelling stack.  */
3875
3876 static void
3877 warning_init (const char *msgid)
3878 {
3879   char *ofwhat;
3880
3881   warning ("%s", _(msgid));
3882   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3883   if (*ofwhat)
3884     warning ("(near initialization for `%s')", ofwhat);
3885 }
3886 \f
3887 /* If TYPE is an array type and EXPR is a parenthesized string
3888    constant, warn if pedantic that EXPR is being used to initialize an
3889    object of type TYPE.  */
3890
3891 void
3892 maybe_warn_string_init (tree type, struct c_expr expr)
3893 {
3894   if (pedantic
3895       && TREE_CODE (type) == ARRAY_TYPE
3896       && TREE_CODE (expr.value) == STRING_CST
3897       && expr.original_code != STRING_CST)
3898     pedwarn_init ("array initialized from parenthesized string constant");
3899 }
3900
3901 /* Digest the parser output INIT as an initializer for type TYPE.
3902    Return a C expression of type TYPE to represent the initial value.
3903
3904    If INIT is a string constant, STRICT_STRING is true if it is
3905    unparenthesized or we should not warn here for it being parenthesized.
3906    For other types of INIT, STRICT_STRING is not used.
3907
3908    REQUIRE_CONSTANT requests an error if non-constant initializers or
3909    elements are seen.  */
3910
3911 static tree
3912 digest_init (tree type, tree init, bool strict_string, int require_constant)
3913 {
3914   enum tree_code code = TREE_CODE (type);
3915   tree inside_init = init;
3916
3917   if (type == error_mark_node
3918       || init == error_mark_node
3919       || TREE_TYPE (init) == error_mark_node)
3920     return error_mark_node;
3921
3922   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3923   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3924      whose value is 0 to count as a null pointer constant.  */
3925   if (TREE_CODE (init) == NON_LVALUE_EXPR)
3926     inside_init = TREE_OPERAND (init, 0);
3927
3928   inside_init = fold (inside_init);
3929
3930   /* Initialization of an array of chars from a string constant
3931      optionally enclosed in braces.  */
3932
3933   if (code == ARRAY_TYPE && inside_init
3934       && TREE_CODE (inside_init) == STRING_CST)
3935     {
3936       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3937       /* Note that an array could be both an array of character type
3938          and an array of wchar_t if wchar_t is signed char or unsigned
3939          char.  */
3940       bool char_array = (typ1 == char_type_node
3941                          || typ1 == signed_char_type_node
3942                          || typ1 == unsigned_char_type_node);
3943       bool wchar_array = !!comptypes (typ1, wchar_type_node);
3944       if (char_array || wchar_array)
3945         {
3946           struct c_expr expr;
3947           bool char_string;
3948           expr.value = inside_init;
3949           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
3950           maybe_warn_string_init (type, expr);
3951
3952           char_string
3953             = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
3954                == char_type_node);
3955
3956           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3957                          TYPE_MAIN_VARIANT (type)))
3958             return inside_init;
3959
3960           if (!wchar_array && !char_string)
3961             {
3962               error_init ("char-array initialized from wide string");
3963               return error_mark_node;
3964             }
3965           if (char_string && !char_array)
3966             {
3967               error_init ("wchar_t-array initialized from non-wide string");
3968               return error_mark_node;
3969             }
3970
3971           TREE_TYPE (inside_init) = type;
3972           if (TYPE_DOMAIN (type) != 0
3973               && TYPE_SIZE (type) != 0
3974               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
3975               /* Subtract 1 (or sizeof (wchar_t))
3976                  because it's ok to ignore the terminating null char
3977                  that is counted in the length of the constant.  */
3978               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
3979                                        TREE_STRING_LENGTH (inside_init)
3980                                        - ((TYPE_PRECISION (typ1)
3981                                            != TYPE_PRECISION (char_type_node))
3982                                           ? (TYPE_PRECISION (wchar_type_node)
3983                                              / BITS_PER_UNIT)
3984                                           : 1)))
3985             pedwarn_init ("initializer-string for array of chars is too long");
3986
3987           return inside_init;
3988         }
3989       else if (INTEGRAL_TYPE_P (typ1))
3990         {
3991           error_init ("array of inappropriate type initialized "
3992                       "from string constant");
3993           return error_mark_node;
3994         }
3995     }
3996
3997   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
3998      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
3999      below and handle as a constructor.  */
4000     if (code == VECTOR_TYPE
4001         && vector_types_convertible_p (TREE_TYPE (inside_init), type)
4002         && TREE_CONSTANT (inside_init))
4003       {
4004         if (TREE_CODE (inside_init) == VECTOR_CST
4005             && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4006                           TYPE_MAIN_VARIANT (type)))
4007           return inside_init;
4008         else
4009           return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
4010       }
4011
4012   /* Any type can be initialized
4013      from an expression of the same type, optionally with braces.  */
4014
4015   if (inside_init && TREE_TYPE (inside_init) != 0
4016       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4017                      TYPE_MAIN_VARIANT (type))
4018           || (code == ARRAY_TYPE
4019               && comptypes (TREE_TYPE (inside_init), type))
4020           || (code == VECTOR_TYPE
4021               && comptypes (TREE_TYPE (inside_init), type))
4022           || (code == POINTER_TYPE
4023               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4024               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4025                             TREE_TYPE (type)))
4026           || (code == POINTER_TYPE
4027               && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
4028               && comptypes (TREE_TYPE (inside_init),
4029                             TREE_TYPE (type)))))
4030     {
4031       if (code == POINTER_TYPE)
4032         {
4033           inside_init = default_function_array_conversion (inside_init);
4034
4035           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4036             {
4037               error_init ("invalid use of non-lvalue array");
4038               return error_mark_node;
4039             }
4040          }
4041
4042       if (code == VECTOR_TYPE)
4043         /* Although the types are compatible, we may require a
4044            conversion.  */
4045         inside_init = convert (type, inside_init);
4046
4047       if (require_constant && !flag_isoc99
4048           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4049         {
4050           /* As an extension, allow initializing objects with static storage
4051              duration with compound literals (which are then treated just as
4052              the brace enclosed list they contain).  */
4053           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4054           inside_init = DECL_INITIAL (decl);
4055         }
4056
4057       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4058           && TREE_CODE (inside_init) != CONSTRUCTOR)
4059         {
4060           error_init ("array initialized from non-constant array expression");
4061           return error_mark_node;
4062         }
4063
4064       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4065         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4066
4067       /* Compound expressions can only occur here if -pedantic or
4068          -pedantic-errors is specified.  In the later case, we always want
4069          an error.  In the former case, we simply want a warning.  */
4070       if (require_constant && pedantic
4071           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4072         {
4073           inside_init
4074             = valid_compound_expr_initializer (inside_init,
4075                                                TREE_TYPE (inside_init));
4076           if (inside_init == error_mark_node)
4077             error_init ("initializer element is not constant");
4078           else
4079             pedwarn_init ("initializer element is not constant");
4080           if (flag_pedantic_errors)
4081             inside_init = error_mark_node;
4082         }
4083       else if (require_constant
4084                && (!TREE_CONSTANT (inside_init)
4085                    /* This test catches things like `7 / 0' which
4086                       result in an expression for which TREE_CONSTANT
4087                       is true, but which is not actually something
4088                       that is a legal constant.  We really should not
4089                       be using this function, because it is a part of
4090                       the back-end.  Instead, the expression should
4091                       already have been turned into ERROR_MARK_NODE.  */
4092                    || !initializer_constant_valid_p (inside_init,
4093                                                      TREE_TYPE (inside_init))))
4094         {
4095           error_init ("initializer element is not constant");
4096           inside_init = error_mark_node;
4097         }
4098
4099       return inside_init;
4100     }
4101
4102   /* Handle scalar types, including conversions.  */
4103
4104   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4105       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
4106       || code == VECTOR_TYPE)
4107     {
4108       /* Note that convert_for_assignment calls default_conversion
4109          for arrays and functions.  We must not call it in the
4110          case where inside_init is a null pointer constant.  */
4111       inside_init
4112         = convert_for_assignment (type, init, _("initialization"),
4113                                   NULL_TREE, NULL_TREE, 0);
4114
4115       if (require_constant && ! TREE_CONSTANT (inside_init))
4116         {
4117           error_init ("initializer element is not constant");
4118           inside_init = error_mark_node;
4119         }
4120       else if (require_constant
4121                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4122         {
4123           error_init ("initializer element is not computable at load time");
4124           inside_init = error_mark_node;
4125         }
4126
4127       return inside_init;
4128     }
4129
4130   /* Come here only for records and arrays.  */
4131
4132   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4133     {
4134       error_init ("variable-sized object may not be initialized");
4135       return error_mark_node;
4136     }
4137
4138   error_init ("invalid initializer");
4139   return error_mark_node;
4140 }
4141 \f
4142 /* Handle initializers that use braces.  */
4143
4144 /* Type of object we are accumulating a constructor for.
4145    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4146 static tree constructor_type;
4147
4148 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4149    left to fill.  */
4150 static tree constructor_fields;
4151
4152 /* For an ARRAY_TYPE, this is the specified index
4153    at which to store the next element we get.  */
4154 static tree constructor_index;
4155
4156 /* For an ARRAY_TYPE, this is the maximum index.  */
4157 static tree constructor_max_index;
4158
4159 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4160 static tree constructor_unfilled_fields;
4161
4162 /* For an ARRAY_TYPE, this is the index of the first element
4163    not yet written out.  */
4164 static tree constructor_unfilled_index;
4165
4166 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4167    This is so we can generate gaps between fields, when appropriate.  */
4168 static tree constructor_bit_index;
4169
4170 /* If we are saving up the elements rather than allocating them,
4171    this is the list of elements so far (in reverse order,
4172    most recent first).  */
4173 static tree constructor_elements;
4174
4175 /* 1 if constructor should be incrementally stored into a constructor chain,
4176    0 if all the elements should be kept in AVL tree.  */
4177 static int constructor_incremental;
4178
4179 /* 1 if so far this constructor's elements are all compile-time constants.  */
4180 static int constructor_constant;
4181
4182 /* 1 if so far this constructor's elements are all valid address constants.  */
4183 static int constructor_simple;
4184
4185 /* 1 if this constructor is erroneous so far.  */
4186 static int constructor_erroneous;
4187
4188 /* Structure for managing pending initializer elements, organized as an
4189    AVL tree.  */
4190
4191 struct init_node
4192 {
4193   struct init_node *left, *right;
4194   struct init_node *parent;
4195   int balance;
4196   tree purpose;
4197   tree value;
4198 };
4199
4200 /* Tree of pending elements at this constructor level.
4201    These are elements encountered out of order
4202    which belong at places we haven't reached yet in actually
4203    writing the output.
4204    Will never hold tree nodes across GC runs.  */
4205 static struct init_node *constructor_pending_elts;
4206
4207 /* The SPELLING_DEPTH of this constructor.  */
4208 static int constructor_depth;
4209
4210 /* 0 if implicitly pushing constructor levels is allowed.  */
4211 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4212
4213 /* DECL node for which an initializer is being read.
4214    0 means we are reading a constructor expression
4215    such as (struct foo) {...}.  */
4216 static tree constructor_decl;
4217
4218 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4219 static const char *constructor_asmspec;
4220
4221 /* Nonzero if this is an initializer for a top-level decl.  */
4222 static int constructor_top_level;
4223
4224 /* Nonzero if there were any member designators in this initializer.  */
4225 static int constructor_designated;
4226
4227 /* Nesting depth of designator list.  */
4228 static int designator_depth;
4229
4230 /* Nonzero if there were diagnosed errors in this designator list.  */
4231 static int designator_errorneous;
4232
4233 \f
4234 /* This stack has a level for each implicit or explicit level of
4235    structuring in the initializer, including the outermost one.  It
4236    saves the values of most of the variables above.  */
4237
4238 struct constructor_range_stack;
4239
4240 struct constructor_stack
4241 {
4242   struct constructor_stack *next;
4243   tree type;
4244   tree fields;
4245   tree index;
4246   tree max_index;
4247   tree unfilled_index;
4248   tree unfilled_fields;
4249   tree bit_index;
4250   tree elements;
4251   struct init_node *pending_elts;
4252   int offset;
4253   int depth;
4254   /* If value nonzero, this value should replace the entire
4255      constructor at this level.  */
4256   struct c_expr replacement_value;
4257   struct constructor_range_stack *range_stack;
4258   char constant;
4259   char simple;
4260   char implicit;
4261   char erroneous;
4262   char outer;
4263   char incremental;
4264   char designated;
4265 };
4266
4267 struct constructor_stack *constructor_stack;
4268
4269 /* This stack represents designators from some range designator up to
4270    the last designator in the list.  */
4271
4272 struct constructor_range_stack
4273 {
4274   struct constructor_range_stack *next, *prev;
4275   struct constructor_stack *stack;
4276   tree range_start;
4277   tree index;
4278   tree range_end;
4279   tree fields;
4280 };
4281
4282 struct constructor_range_stack *constructor_range_stack;
4283
4284 /* This stack records separate initializers that are nested.
4285    Nested initializers can't happen in ANSI C, but GNU C allows them
4286    in cases like { ... (struct foo) { ... } ... }.  */
4287
4288 struct initializer_stack
4289 {
4290   struct initializer_stack *next;
4291   tree decl;
4292   const char *asmspec;
4293   struct constructor_stack *constructor_stack;
4294   struct constructor_range_stack *constructor_range_stack;
4295   tree elements;
4296   struct spelling *spelling;
4297   struct spelling *spelling_base;
4298   int spelling_size;
4299   char top_level;
4300   char require_constant_value;
4301   char require_constant_elements;
4302 };
4303
4304 struct initializer_stack *initializer_stack;
4305 \f
4306 /* Prepare to parse and output the initializer for variable DECL.  */
4307
4308 void
4309 start_init (tree decl, tree asmspec_tree, int top_level)
4310 {
4311   const char *locus;
4312   struct initializer_stack *p = XNEW (struct initializer_stack);
4313   const char *asmspec = 0;
4314
4315   if (asmspec_tree)
4316     asmspec = TREE_STRING_POINTER (asmspec_tree);
4317
4318   p->decl = constructor_decl;
4319   p->asmspec = constructor_asmspec;
4320   p->require_constant_value = require_constant_value;
4321   p->require_constant_elements = require_constant_elements;
4322   p->constructor_stack = constructor_stack;
4323   p->constructor_range_stack = constructor_range_stack;
4324   p->elements = constructor_elements;
4325   p->spelling = spelling;
4326   p->spelling_base = spelling_base;
4327   p->spelling_size = spelling_size;
4328   p->top_level = constructor_top_level;
4329   p->next = initializer_stack;
4330   initializer_stack = p;
4331
4332   constructor_decl = decl;
4333   constructor_asmspec = asmspec;
4334   constructor_designated = 0;
4335   constructor_top_level = top_level;
4336
4337   if (decl != 0)
4338     {
4339       require_constant_value = TREE_STATIC (decl);
4340       require_constant_elements
4341         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4342            /* For a scalar, you can always use any value to initialize,
4343               even within braces.  */
4344            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4345                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4346                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4347                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4348       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4349     }
4350   else
4351     {
4352       require_constant_value = 0;
4353       require_constant_elements = 0;
4354       locus = "(anonymous)";
4355     }
4356
4357   constructor_stack = 0;
4358   constructor_range_stack = 0;
4359
4360   missing_braces_mentioned = 0;
4361
4362   spelling_base = 0;
4363   spelling_size = 0;
4364   RESTORE_SPELLING_DEPTH (0);
4365
4366   if (locus)
4367     push_string (locus);
4368 }
4369
4370 void
4371 finish_init (void)
4372 {
4373   struct initializer_stack *p = initializer_stack;
4374
4375   /* Free the whole constructor stack of this initializer.  */
4376   while (constructor_stack)
4377     {
4378       struct constructor_stack *q = constructor_stack;
4379       constructor_stack = q->next;
4380       free (q);
4381     }
4382
4383   if (constructor_range_stack)
4384     abort ();
4385
4386   /* Pop back to the data of the outer initializer (if any).  */
4387   free (spelling_base);
4388
4389   constructor_decl = p->decl;
4390   constructor_asmspec = p->asmspec;
4391   require_constant_value = p->require_constant_value;
4392   require_constant_elements = p->require_constant_elements;
4393   constructor_stack = p->constructor_stack;
4394   constructor_range_stack = p->constructor_range_stack;
4395   constructor_elements = p->elements;
4396   spelling = p->spelling;
4397   spelling_base = p->spelling_base;
4398   spelling_size = p->spelling_size;
4399   constructor_top_level = p->top_level;
4400   initializer_stack = p->next;
4401   free (p);
4402 }
4403 \f
4404 /* Call here when we see the initializer is surrounded by braces.
4405    This is instead of a call to push_init_level;
4406    it is matched by a call to pop_init_level.
4407
4408    TYPE is the type to initialize, for a constructor expression.
4409    For an initializer for a decl, TYPE is zero.  */
4410
4411 void
4412 really_start_incremental_init (tree type)
4413 {
4414   struct constructor_stack *p = XNEW (struct constructor_stack);
4415
4416   if (type == 0)
4417     type = TREE_TYPE (constructor_decl);
4418
4419   if (targetm.vector_opaque_p (type))
4420     error ("opaque vector types cannot be initialized");
4421
4422   p->type = constructor_type;
4423   p->fields = constructor_fields;
4424   p->index = constructor_index;
4425   p->max_index = constructor_max_index;
4426   p->unfilled_index = constructor_unfilled_index;
4427   p->unfilled_fields = constructor_unfilled_fields;
4428   p->bit_index = constructor_bit_index;
4429   p->elements = constructor_elements;
4430   p->constant = constructor_constant;
4431   p->simple = constructor_simple;
4432   p->erroneous = constructor_erroneous;
4433   p->pending_elts = constructor_pending_elts;
4434   p->depth = constructor_depth;
4435   p->replacement_value.value = 0;
4436   p->replacement_value.original_code = ERROR_MARK;
4437   p->implicit = 0;
4438   p->range_stack = 0;
4439   p->outer = 0;
4440   p->incremental = constructor_incremental;
4441   p->designated = constructor_designated;
4442   p->next = 0;
4443   constructor_stack = p;
4444
4445   constructor_constant = 1;
4446   constructor_simple = 1;
4447   constructor_depth = SPELLING_DEPTH ();
4448   constructor_elements = 0;
4449   constructor_pending_elts = 0;
4450   constructor_type = type;
4451   constructor_incremental = 1;
4452   constructor_designated = 0;
4453   designator_depth = 0;
4454   designator_errorneous = 0;
4455
4456   if (TREE_CODE (constructor_type) == RECORD_TYPE
4457       || TREE_CODE (constructor_type) == UNION_TYPE)
4458     {
4459       constructor_fields = TYPE_FIELDS (constructor_type);
4460       /* Skip any nameless bit fields at the beginning.  */
4461       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4462              && DECL_NAME (constructor_fields) == 0)
4463         constructor_fields = TREE_CHAIN (constructor_fields);
4464
4465       constructor_unfilled_fields = constructor_fields;
4466       constructor_bit_index = bitsize_zero_node;
4467     }
4468   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4469     {
4470       if (TYPE_DOMAIN (constructor_type))
4471         {
4472           constructor_max_index
4473             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4474
4475           /* Detect non-empty initializations of zero-length arrays.  */
4476           if (constructor_max_index == NULL_TREE
4477               && TYPE_SIZE (constructor_type))
4478             constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
4479
4480           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4481              to initialize VLAs will cause a proper error; avoid tree
4482              checking errors as well by setting a safe value.  */
4483           if (constructor_max_index
4484               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4485             constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
4486
4487           constructor_index
4488             = convert (bitsizetype,
4489                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4490         }
4491       else
4492         constructor_index = bitsize_zero_node;
4493
4494       constructor_unfilled_index = constructor_index;
4495     }
4496   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4497     {
4498       /* Vectors are like simple fixed-size arrays.  */
4499       constructor_max_index =
4500         build_int_cst (NULL_TREE,
4501                        TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4502       constructor_index = convert (bitsizetype, bitsize_zero_node);
4503       constructor_unfilled_index = constructor_index;
4504     }
4505   else
4506     {
4507       /* Handle the case of int x = {5}; */
4508       constructor_fields = constructor_type;
4509       constructor_unfilled_fields = constructor_type;
4510     }
4511 }
4512 \f
4513 /* Push down into a subobject, for initialization.
4514    If this is for an explicit set of braces, IMPLICIT is 0.
4515    If it is because the next element belongs at a lower level,
4516    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4517
4518 void
4519 push_init_level (int implicit)
4520 {
4521   struct constructor_stack *p;
4522   tree value = NULL_TREE;
4523
4524   /* If we've exhausted any levels that didn't have braces,
4525      pop them now.  */
4526   while (constructor_stack->implicit)
4527     {
4528       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4529            || TREE_CODE (constructor_type) == UNION_TYPE)
4530           && constructor_fields == 0)
4531         process_init_element (pop_init_level (1));
4532       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4533                && constructor_max_index
4534                && tree_int_cst_lt (constructor_max_index, constructor_index))
4535         process_init_element (pop_init_level (1));
4536       else
4537         break;
4538     }
4539
4540   /* Unless this is an explicit brace, we need to preserve previous
4541      content if any.  */
4542   if (implicit)
4543     {
4544       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4545            || TREE_CODE (constructor_type) == UNION_TYPE)
4546           && constructor_fields)
4547         value = find_init_member (constructor_fields);
4548       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4549         value = find_init_member (constructor_index);
4550     }
4551
4552   p = XNEW (struct constructor_stack);
4553   p->type = constructor_type;
4554   p->fields = constructor_fields;
4555   p->index = constructor_index;
4556   p->max_index = constructor_max_index;
4557   p->unfilled_index = constructor_unfilled_index;
4558   p->unfilled_fields = constructor_unfilled_fields;
4559   p->bit_index = constructor_bit_index;
4560   p->elements = constructor_elements;
4561   p->constant = constructor_constant;
4562   p->simple = constructor_simple;
4563   p->erroneous = constructor_erroneous;
4564   p->pending_elts = constructor_pending_elts;
4565   p->depth = constructor_depth;
4566   p->replacement_value.value = 0;
4567   p->replacement_value.original_code = ERROR_MARK;
4568   p->implicit = implicit;
4569   p->outer = 0;
4570   p->incremental = constructor_incremental;
4571   p->designated = constructor_designated;
4572   p->next = constructor_stack;
4573   p->range_stack = 0;
4574   constructor_stack = p;
4575
4576   constructor_constant = 1;
4577   constructor_simple = 1;
4578   constructor_depth = SPELLING_DEPTH ();
4579   constructor_elements = 0;
4580   constructor_incremental = 1;
4581   constructor_designated = 0;
4582   constructor_pending_elts = 0;
4583   if (!implicit)
4584     {
4585       p->range_stack = constructor_range_stack;
4586       constructor_range_stack = 0;
4587       designator_depth = 0;
4588       designator_errorneous = 0;
4589     }
4590
4591   /* Don't die if an entire brace-pair level is superfluous
4592      in the containing level.  */
4593   if (constructor_type == 0)
4594     ;
4595   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4596            || TREE_CODE (constructor_type) == UNION_TYPE)
4597     {
4598       /* Don't die if there are extra init elts at the end.  */
4599       if (constructor_fields == 0)
4600         constructor_type = 0;
4601       else
4602         {
4603           constructor_type = TREE_TYPE (constructor_fields);
4604           push_member_name (constructor_fields);
4605           constructor_depth++;
4606         }
4607     }
4608   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4609     {
4610       constructor_type = TREE_TYPE (constructor_type);
4611       push_array_bounds (tree_low_cst (constructor_index, 0));
4612       constructor_depth++;
4613     }
4614
4615   if (constructor_type == 0)
4616     {
4617       error_init ("extra brace group at end of initializer");
4618       constructor_fields = 0;
4619       constructor_unfilled_fields = 0;
4620       return;
4621     }
4622
4623   if (value && TREE_CODE (value) == CONSTRUCTOR)
4624     {
4625       constructor_constant = TREE_CONSTANT (value);
4626       constructor_simple = TREE_STATIC (value);
4627       constructor_elements = CONSTRUCTOR_ELTS (value);
4628       if (constructor_elements
4629           && (TREE_CODE (constructor_type) == RECORD_TYPE
4630               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4631         set_nonincremental_init ();
4632     }
4633
4634   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4635     {
4636       missing_braces_mentioned = 1;
4637       warning_init ("missing braces around initializer");
4638     }
4639
4640   if (TREE_CODE (constructor_type) == RECORD_TYPE
4641            || TREE_CODE (constructor_type) == UNION_TYPE)
4642     {
4643       constructor_fields = TYPE_FIELDS (constructor_type);
4644       /* Skip any nameless bit fields at the beginning.  */
4645       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4646              && DECL_NAME (constructor_fields) == 0)
4647         constructor_fields = TREE_CHAIN (constructor_fields);
4648
4649       constructor_unfilled_fields = constructor_fields;
4650       constructor_bit_index = bitsize_zero_node;
4651     }
4652   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4653     {
4654       /* Vectors are like simple fixed-size arrays.  */
4655       constructor_max_index =
4656         build_int_cst (NULL_TREE,
4657                        TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4658       constructor_index = convert (bitsizetype, integer_zero_node);
4659       constructor_unfilled_index = constructor_index;
4660     }
4661   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4662     {
4663       if (TYPE_DOMAIN (constructor_type))
4664         {
4665           constructor_max_index
4666             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4667
4668           /* Detect non-empty initializations of zero-length arrays.  */
4669           if (constructor_max_index == NULL_TREE
4670               && TYPE_SIZE (constructor_type))
4671             constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
4672
4673           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4674              to initialize VLAs will cause a proper error; avoid tree
4675              checking errors as well by setting a safe value.  */
4676           if (constructor_max_index
4677               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4678             constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
4679
4680           constructor_index
4681             = convert (bitsizetype,
4682                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4683         }
4684       else
4685         constructor_index = bitsize_zero_node;
4686
4687       constructor_unfilled_index = constructor_index;
4688       if (value && TREE_CODE (value) == STRING_CST)
4689         {
4690           /* We need to split the char/wchar array into individual
4691              characters, so that we don't have to special case it
4692              everywhere.  */
4693           set_nonincremental_init_from_string (value);
4694         }
4695     }
4696   else
4697     {
4698       warning_init ("braces around scalar initializer");
4699       constructor_fields = constructor_type;
4700       constructor_unfilled_fields = constructor_type;
4701     }
4702 }
4703
4704 /* At the end of an implicit or explicit brace level,
4705    finish up that level of constructor.  If a single expression
4706    with redundant braces initialized that level, return the
4707    c_expr structure for that expression.  Otherwise, the original_code
4708    element is set to ERROR_MARK.
4709    If we were outputting the elements as they are read, return 0 as the value
4710    from inner levels (process_init_element ignores that),
4711    but return error_mark_node as the value from the outermost level
4712    (that's what we want to put in DECL_INITIAL).
4713    Otherwise, return a CONSTRUCTOR expression as the value.  */
4714
4715 struct c_expr
4716 pop_init_level (int implicit)
4717 {
4718   struct constructor_stack *p;
4719   struct c_expr ret;
4720   ret.value = 0;
4721   ret.original_code = ERROR_MARK;
4722
4723   if (implicit == 0)
4724     {
4725       /* When we come to an explicit close brace,
4726          pop any inner levels that didn't have explicit braces.  */
4727       while (constructor_stack->implicit)
4728         process_init_element (pop_init_level (1));
4729
4730       if (constructor_range_stack)
4731         abort ();
4732     }
4733
4734   /* Now output all pending elements.  */
4735   constructor_incremental = 1;
4736   output_pending_init_elements (1);
4737
4738   p = constructor_stack;
4739
4740   /* Error for initializing a flexible array member, or a zero-length
4741      array member in an inappropriate context.  */
4742   if (constructor_type && constructor_fields
4743       && TREE_CODE (constructor_type) == ARRAY_TYPE
4744       && TYPE_DOMAIN (constructor_type)
4745       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4746     {
4747       /* Silently discard empty initializations.  The parser will
4748          already have pedwarned for empty brackets.  */
4749       if (integer_zerop (constructor_unfilled_index))
4750         constructor_type = NULL_TREE;
4751       else if (! TYPE_SIZE (constructor_type))
4752         {
4753           if (constructor_depth > 2)
4754             error_init ("initialization of flexible array member in a nested context");
4755           else if (pedantic)
4756             pedwarn_init ("initialization of a flexible array member");
4757
4758           /* We have already issued an error message for the existence
4759              of a flexible array member not at the end of the structure.
4760              Discard the initializer so that we do not abort later.  */
4761           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4762             constructor_type = NULL_TREE;
4763         }
4764       else
4765         /* Zero-length arrays are no longer special, so we should no longer
4766            get here.  */
4767         abort ();
4768     }
4769
4770   /* Warn when some struct elements are implicitly initialized to zero.  */
4771   if (warn_missing_field_initializers
4772       && constructor_type
4773       && TREE_CODE (constructor_type) == RECORD_TYPE
4774       && constructor_unfilled_fields)
4775     {
4776         /* Do not warn for flexible array members or zero-length arrays.  */
4777         while (constructor_unfilled_fields
4778                && (! DECL_SIZE (constructor_unfilled_fields)
4779                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4780           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4781
4782         /* Do not warn if this level of the initializer uses member
4783            designators; it is likely to be deliberate.  */
4784         if (constructor_unfilled_fields && !constructor_designated)
4785           {
4786             push_member_name (constructor_unfilled_fields);
4787             warning_init ("missing initializer");
4788             RESTORE_SPELLING_DEPTH (constructor_depth);
4789           }
4790     }
4791
4792   /* Pad out the end of the structure.  */
4793   if (p->replacement_value.value)
4794     /* If this closes a superfluous brace pair,
4795        just pass out the element between them.  */
4796     ret = p->replacement_value;
4797   else if (constructor_type == 0)
4798     ;
4799   else if (TREE_CODE (constructor_type) != RECORD_TYPE
4800            && TREE_CODE (constructor_type) != UNION_TYPE
4801            && TREE_CODE (constructor_type) != ARRAY_TYPE
4802            && TREE_CODE (constructor_type) != VECTOR_TYPE)
4803     {
4804       /* A nonincremental scalar initializer--just return
4805          the element, after verifying there is just one.  */
4806       if (constructor_elements == 0)
4807         {
4808           if (!constructor_erroneous)
4809             error_init ("empty scalar initializer");
4810           ret.value = error_mark_node;
4811         }
4812       else if (TREE_CHAIN (constructor_elements) != 0)
4813         {
4814           error_init ("extra elements in scalar initializer");
4815           ret.value = TREE_VALUE (constructor_elements);
4816         }
4817       else
4818         ret.value = TREE_VALUE (constructor_elements);
4819     }
4820   else
4821     {
4822       if (constructor_erroneous)
4823         ret.value = error_mark_node;
4824       else
4825         {
4826           ret.value = build_constructor (constructor_type,
4827                                          nreverse (constructor_elements));
4828           if (constructor_constant)
4829             TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
4830           if (constructor_constant && constructor_simple)
4831             TREE_STATIC (ret.value) = 1;
4832         }
4833     }
4834
4835   constructor_type = p->type;
4836   constructor_fields = p->fields;
4837   constructor_index = p->index;
4838   constructor_max_index = p->max_index;
4839   constructor_unfilled_index = p->unfilled_index;
4840   constructor_unfilled_fields = p->unfilled_fields;
4841   constructor_bit_index = p->bit_index;
4842   constructor_elements = p->elements;
4843   constructor_constant = p->constant;
4844   constructor_simple = p->simple;
4845   constructor_erroneous = p->erroneous;
4846   constructor_incremental = p->incremental;
4847   constructor_designated = p->designated;
4848   constructor_pending_elts = p->pending_elts;
4849   constructor_depth = p->depth;
4850   if (!p->implicit)
4851     constructor_range_stack = p->range_stack;
4852   RESTORE_SPELLING_DEPTH (constructor_depth);
4853
4854   constructor_stack = p->next;
4855   free (p);
4856
4857   if (ret.value == 0)
4858     {
4859       if (constructor_stack == 0)
4860         {
4861           ret.value = error_mark_node;
4862           return ret;
4863         }
4864       return ret;
4865     }
4866   return ret;
4867 }
4868
4869 /* Common handling for both array range and field name designators.
4870    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
4871
4872 static int
4873 set_designator (int array)
4874 {
4875   tree subtype;
4876   enum tree_code subcode;
4877
4878   /* Don't die if an entire brace-pair level is superfluous
4879      in the containing level.  */
4880   if (constructor_type == 0)
4881     return 1;
4882
4883   /* If there were errors in this designator list already, bail out silently.  */
4884   if (designator_errorneous)
4885     return 1;
4886
4887   if (!designator_depth)
4888     {
4889       if (constructor_range_stack)
4890         abort ();
4891
4892       /* Designator list starts at the level of closest explicit
4893          braces.  */
4894       while (constructor_stack->implicit)
4895         process_init_element (pop_init_level (1));
4896       constructor_designated = 1;
4897       return 0;
4898     }
4899
4900   if (constructor_no_implicit)
4901     {
4902       error_init ("initialization designators may not nest");
4903       return 1;
4904     }
4905
4906   if (TREE_CODE (constructor_type) == RECORD_TYPE
4907       || TREE_CODE (constructor_type) == UNION_TYPE)
4908     {
4909       subtype = TREE_TYPE (constructor_fields);
4910       if (subtype != error_mark_node)
4911         subtype = TYPE_MAIN_VARIANT (subtype);
4912     }
4913   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4914     {
4915       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
4916     }
4917   else
4918     abort ();
4919
4920   subcode = TREE_CODE (subtype);
4921   if (array && subcode != ARRAY_TYPE)
4922     {
4923       error_init ("array index in non-array initializer");
4924       return 1;
4925     }
4926   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
4927     {
4928       error_init ("field name not in record or union initializer");
4929       return 1;
4930     }
4931
4932   constructor_designated = 1;
4933   push_init_level (2);
4934   return 0;
4935 }
4936
4937 /* If there are range designators in designator list, push a new designator
4938    to constructor_range_stack.  RANGE_END is end of such stack range or
4939    NULL_TREE if there is no range designator at this level.  */
4940
4941 static void
4942 push_range_stack (tree range_end)
4943 {
4944   struct constructor_range_stack *p;
4945
4946   p = GGC_NEW (struct constructor_range_stack);
4947   p->prev = constructor_range_stack;
4948   p->next = 0;
4949   p->fields = constructor_fields;
4950   p->range_start = constructor_index;
4951   p->index = constructor_index;
4952   p->stack = constructor_stack;
4953   p->range_end = range_end;
4954   if (constructor_range_stack)
4955     constructor_range_stack->next = p;
4956   constructor_range_stack = p;
4957 }
4958
4959 /* Within an array initializer, specify the next index to be initialized.
4960    FIRST is that index.  If LAST is nonzero, then initialize a range
4961    of indices, running from FIRST through LAST.  */
4962
4963 void
4964 set_init_index (tree first, tree last)
4965 {
4966   if (set_designator (1))
4967     return;
4968
4969   designator_errorneous = 1;
4970
4971   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
4972       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
4973     {
4974       error_init ("array index in initializer not of integer type");
4975       return;
4976     }
4977
4978   while ((TREE_CODE (first) == NOP_EXPR
4979           || TREE_CODE (first) == CONVERT_EXPR
4980           || TREE_CODE (first) == NON_LVALUE_EXPR)
4981          && (TYPE_MODE (TREE_TYPE (first))
4982              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
4983     first = TREE_OPERAND (first, 0);
4984
4985   if (last)
4986     while ((TREE_CODE (last) == NOP_EXPR
4987             || TREE_CODE (last) == CONVERT_EXPR
4988             || TREE_CODE (last) == NON_LVALUE_EXPR)
4989            && (TYPE_MODE (TREE_TYPE (last))
4990                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
4991       last = TREE_OPERAND (last, 0);
4992
4993   if (TREE_CODE (first) != INTEGER_CST)
4994     error_init ("nonconstant array index in initializer");
4995   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
4996     error_init ("nonconstant array index in initializer");
4997   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
4998     error_init ("array index in non-array initializer");
4999   else if (tree_int_cst_sgn (first) == -1)
5000     error_init ("array index in initializer exceeds array bounds");
5001   else if (constructor_max_index
5002            && tree_int_cst_lt (constructor_max_index, first))
5003     error_init ("array index in initializer exceeds array bounds");
5004   else
5005     {
5006       constructor_index = convert (bitsizetype, first);
5007
5008       if (last)
5009         {
5010           if (tree_int_cst_equal (first, last))
5011             last = 0;
5012           else if (tree_int_cst_lt (last, first))
5013             {
5014               error_init ("empty index range in initializer");
5015               last = 0;
5016             }
5017           else
5018             {
5019               last = convert (bitsizetype, last);
5020               if (constructor_max_index != 0
5021                   && tree_int_cst_lt (constructor_max_index, last))
5022                 {
5023                   error_init ("array index range in initializer exceeds array bounds");
5024                   last = 0;
5025                 }
5026             }
5027         }
5028
5029       designator_depth++;
5030       designator_errorneous = 0;
5031       if (constructor_range_stack || last)
5032         push_range_stack (last);
5033     }
5034 }
5035
5036 /* Within a struct initializer, specify the next field to be initialized.  */
5037
5038 void
5039 set_init_label (tree fieldname)
5040 {
5041   tree tail;
5042
5043   if (set_designator (0))
5044     return;
5045
5046   designator_errorneous = 1;
5047
5048   if (TREE_CODE (constructor_type) != RECORD_TYPE
5049       && TREE_CODE (constructor_type) != UNION_TYPE)
5050     {
5051       error_init ("field name not in record or union initializer");
5052       return;
5053     }
5054
5055   for (tail = TYPE_FIELDS (constructor_type); tail;
5056        tail = TREE_CHAIN (tail))
5057     {
5058       if (DECL_NAME (tail) == fieldname)
5059         break;
5060     }
5061
5062   if (tail == 0)
5063     error ("unknown field `%s' specified in initializer",
5064            IDENTIFIER_POINTER (fieldname));
5065   else
5066     {
5067       constructor_fields = tail;
5068       designator_depth++;
5069       designator_errorneous = 0;
5070       if (constructor_range_stack)
5071         push_range_stack (NULL_TREE);
5072     }
5073 }
5074 \f
5075 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5076    identifies the initializer, either array index or field in a structure.
5077    VALUE is the value of that index or field.  */
5078
5079 static void
5080 add_pending_init (tree purpose, tree value)
5081 {
5082   struct init_node *p, **q, *r;
5083
5084   q = &constructor_pending_elts;
5085   p = 0;
5086
5087   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5088     {
5089       while (*q != 0)
5090         {
5091           p = *q;
5092           if (tree_int_cst_lt (purpose, p->purpose))
5093             q = &p->left;
5094           else if (tree_int_cst_lt (p->purpose, purpose))
5095             q = &p->right;
5096           else
5097             {
5098               if (TREE_SIDE_EFFECTS (p->value))
5099                 warning_init ("initialized field with side-effects overwritten");
5100               p->value = value;
5101               return;
5102             }
5103         }
5104     }
5105   else
5106     {
5107       tree bitpos;
5108
5109       bitpos = bit_position (purpose);
5110       while (*q != NULL)
5111         {
5112           p = *q;
5113           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5114             q = &p->left;
5115           else if (p->purpose != purpose)
5116             q = &p->right;
5117           else
5118             {
5119               if (TREE_SIDE_EFFECTS (p->value))
5120                 warning_init ("initialized field with side-effects overwritten");
5121               p->value = value;
5122               return;
5123             }
5124         }
5125     }
5126
5127   r = GGC_NEW (struct init_node);
5128   r->purpose = purpose;
5129   r->value = value;
5130
5131   *q = r;
5132   r->parent = p;
5133   r->left = 0;
5134   r->right = 0;
5135   r->balance = 0;
5136
5137   while (p)
5138     {
5139       struct init_node *s;
5140
5141       if (r == p->left)
5142         {
5143           if (p->balance == 0)
5144             p->balance = -1;
5145           else if (p->balance < 0)
5146             {
5147               if (r->balance < 0)
5148                 {
5149                   /* L rotation.  */
5150                   p->left = r->right;
5151                   if (p->left)
5152                     p->left->parent = p;
5153                   r->right = p;
5154
5155                   p->balance = 0;
5156                   r->balance = 0;
5157
5158                   s = p->parent;
5159                   p->parent = r;
5160                   r->parent = s;
5161                   if (s)
5162                     {
5163                       if (s->left == p)
5164                         s->left = r;
5165                       else
5166                         s->right = r;
5167                     }
5168                   else
5169                     constructor_pending_elts = r;
5170                 }
5171               else
5172                 {
5173                   /* LR rotation.  */
5174                   struct init_node *t = r->right;
5175
5176                   r->right = t->left;
5177                   if (r->right)
5178                     r->right->parent = r;
5179                   t->left = r;
5180
5181                   p->left = t->right;
5182                   if (p->left)
5183                     p->left->parent = p;
5184                   t->right = p;
5185
5186                   p->balance = t->balance < 0;
5187                   r->balance = -(t->balance > 0);
5188                   t->balance = 0;
5189
5190                   s = p->parent;
5191                   p->parent = t;
5192                   r->parent = t;
5193                   t->parent = s;
5194                   if (s)
5195                     {
5196                       if (s->left == p)
5197                         s->left = t;
5198                       else
5199                         s->right = t;
5200                     }
5201                   else
5202                     constructor_pending_elts = t;
5203                 }
5204               break;
5205             }
5206           else
5207             {
5208               /* p->balance == +1; growth of left side balances the node.  */
5209               p->balance = 0;
5210               break;
5211             }
5212         }
5213       else /* r == p->right */
5214         {
5215           if (p->balance == 0)
5216             /* Growth propagation from right side.  */
5217             p->balance++;
5218           else if (p->balance > 0)
5219             {
5220               if (r->balance > 0)
5221                 {
5222                   /* R rotation.  */
5223                   p->right = r->left;
5224                   if (p->right)
5225                     p->right->parent = p;
5226                   r->left = p;
5227
5228                   p->balance = 0;
5229                   r->balance = 0;
5230
5231                   s = p->parent;
5232                   p->parent = r;
5233                   r->parent = s;
5234                   if (s)
5235                     {
5236                       if (s->left == p)
5237                         s->left = r;
5238                       else
5239                         s->right = r;
5240                     }
5241                   else
5242                     constructor_pending_elts = r;
5243                 }
5244               else /* r->balance == -1 */
5245                 {
5246                   /* RL rotation */
5247                   struct init_node *t = r->left;
5248
5249                   r->left = t->right;
5250                   if (r->left)
5251                     r->left->parent = r;
5252                   t->right = r;
5253
5254                   p->right = t->left;
5255                   if (p->right)
5256                     p->right->parent = p;
5257                   t->left = p;
5258
5259                   r->balance = (t->balance < 0);
5260                   p->balance = -(t->balance > 0);
5261                   t->balance = 0;
5262
5263                   s = p->parent;
5264                   p->parent = t;
5265                   r->parent = t;
5266                   t->parent = s;
5267                   if (s)
5268                     {
5269                       if (s->left == p)
5270                         s->left = t;
5271                       else
5272                         s->right = t;
5273                     }
5274                   else
5275                     constructor_pending_elts = t;
5276                 }
5277               break;
5278             }
5279           else
5280             {
5281               /* p->balance == -1; growth of right side balances the node.  */
5282               p->balance = 0;
5283               break;
5284             }
5285         }
5286
5287       r = p;
5288       p = p->parent;
5289     }
5290 }
5291
5292 /* Build AVL tree from a sorted chain.  */
5293
5294 static void
5295 set_nonincremental_init (void)
5296 {
5297   tree chain;
5298
5299   if (TREE_CODE (constructor_type) != RECORD_TYPE
5300       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5301     return;
5302
5303   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5304     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5305   constructor_elements = 0;
5306   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5307     {
5308       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5309       /* Skip any nameless bit fields at the beginning.  */
5310       while (constructor_unfilled_fields != 0
5311              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5312              && DECL_NAME (constructor_unfilled_fields) == 0)
5313         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5314
5315     }
5316   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5317     {
5318       if (TYPE_DOMAIN (constructor_type))
5319         constructor_unfilled_index
5320             = convert (bitsizetype,
5321                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5322       else
5323         constructor_unfilled_index = bitsize_zero_node;
5324     }
5325   constructor_incremental = 0;
5326 }
5327
5328 /* Build AVL tree from a string constant.  */
5329
5330 static void
5331 set_nonincremental_init_from_string (tree str)
5332 {
5333   tree value, purpose, type;
5334   HOST_WIDE_INT val[2];
5335   const char *p, *end;
5336   int byte, wchar_bytes, charwidth, bitpos;
5337
5338   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5339     abort ();
5340
5341   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5342       == TYPE_PRECISION (char_type_node))
5343     wchar_bytes = 1;
5344   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5345            == TYPE_PRECISION (wchar_type_node))
5346     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5347   else
5348     abort ();
5349
5350   charwidth = TYPE_PRECISION (char_type_node);
5351   type = TREE_TYPE (constructor_type);
5352   p = TREE_STRING_POINTER (str);
5353   end = p + TREE_STRING_LENGTH (str);
5354
5355   for (purpose = bitsize_zero_node;
5356        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5357        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5358     {
5359       if (wchar_bytes == 1)
5360         {
5361           val[1] = (unsigned char) *p++;
5362           val[0] = 0;
5363         }
5364       else
5365         {
5366           val[0] = 0;
5367           val[1] = 0;
5368           for (byte = 0; byte < wchar_bytes; byte++)
5369             {
5370               if (BYTES_BIG_ENDIAN)
5371                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5372               else
5373                 bitpos = byte * charwidth;
5374               val[bitpos < HOST_BITS_PER_WIDE_INT]
5375                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5376                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5377             }
5378         }
5379
5380       if (!TYPE_UNSIGNED (type))
5381         {
5382           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5383           if (bitpos < HOST_BITS_PER_WIDE_INT)
5384             {
5385               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5386                 {
5387                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5388                   val[0] = -1;
5389                 }
5390             }
5391           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5392             {
5393               if (val[1] < 0)
5394                 val[0] = -1;
5395             }
5396           else if (val[0] & (((HOST_WIDE_INT) 1)
5397                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5398             val[0] |= ((HOST_WIDE_INT) -1)
5399                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5400         }
5401
5402       value = build_int_cst (type, val[1], val[0]);
5403       add_pending_init (purpose, value);
5404     }
5405
5406   constructor_incremental = 0;
5407 }
5408
5409 /* Return value of FIELD in pending initializer or zero if the field was
5410    not initialized yet.  */
5411
5412 static tree
5413 find_init_member (tree field)
5414 {
5415   struct init_node *p;
5416
5417   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5418     {
5419       if (constructor_incremental
5420           && tree_int_cst_lt (field, constructor_unfilled_index))
5421         set_nonincremental_init ();
5422
5423       p = constructor_pending_elts;
5424       while (p)
5425         {
5426           if (tree_int_cst_lt (field, p->purpose))
5427             p = p->left;
5428           else if (tree_int_cst_lt (p->purpose, field))
5429             p = p->right;
5430           else
5431             return p->value;
5432         }
5433     }
5434   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5435     {
5436       tree bitpos = bit_position (field);
5437
5438       if (constructor_incremental
5439           && (!constructor_unfilled_fields
5440               || tree_int_cst_lt (bitpos,
5441                                   bit_position (constructor_unfilled_fields))))
5442         set_nonincremental_init ();
5443
5444       p = constructor_pending_elts;
5445       while (p)
5446         {
5447           if (field == p->purpose)
5448             return p->value;
5449           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5450             p = p->left;
5451           else
5452             p = p->right;
5453         }
5454     }
5455   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5456     {
5457       if (constructor_elements
5458           && TREE_PURPOSE (constructor_elements) == field)
5459         return TREE_VALUE (constructor_elements);
5460     }
5461   return 0;
5462 }
5463
5464 /* "Output" the next constructor element.
5465    At top level, really output it to assembler code now.
5466    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5467    TYPE is the data type that the containing data type wants here.
5468    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5469    If VALUE is a string constant, STRICT_STRING is true if it is
5470    unparenthesized or we should not warn here for it being parenthesized.
5471    For other types of VALUE, STRICT_STRING is not used.
5472
5473    PENDING if non-nil means output pending elements that belong
5474    right after this element.  (PENDING is normally 1;
5475    it is 0 while outputting pending elements, to avoid recursion.)  */
5476
5477 static void
5478 output_init_element (tree value, bool strict_string, tree type, tree field,
5479                      int pending)
5480 {
5481   if (type == error_mark_node)
5482     {
5483       constructor_erroneous = 1;
5484       return;
5485     }
5486   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5487       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5488           && !(TREE_CODE (value) == STRING_CST
5489                && TREE_CODE (type) == ARRAY_TYPE
5490                && INTEGRAL_TYPE_P (TREE_TYPE (type)))
5491           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5492                          TYPE_MAIN_VARIANT (type))))
5493     value = default_conversion (value);
5494
5495   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5496       && require_constant_value && !flag_isoc99 && pending)
5497     {
5498       /* As an extension, allow initializing objects with static storage
5499          duration with compound literals (which are then treated just as
5500          the brace enclosed list they contain).  */
5501       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5502       value = DECL_INITIAL (decl);
5503     }
5504
5505   if (value == error_mark_node)
5506     constructor_erroneous = 1;
5507   else if (!TREE_CONSTANT (value))
5508     constructor_constant = 0;
5509   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5510            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5511                 || TREE_CODE (constructor_type) == UNION_TYPE)
5512                && DECL_C_BIT_FIELD (field)
5513                && TREE_CODE (value) != INTEGER_CST))
5514     constructor_simple = 0;
5515
5516   if (require_constant_value && ! TREE_CONSTANT (value))
5517     {
5518       error_init ("initializer element is not constant");
5519       value = error_mark_node;
5520     }
5521   else if (require_constant_elements
5522            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5523     pedwarn ("initializer element is not computable at load time");
5524
5525   /* If this field is empty (and not at the end of structure),
5526      don't do anything other than checking the initializer.  */
5527   if (field
5528       && (TREE_TYPE (field) == error_mark_node
5529           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5530               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5531               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5532                   || TREE_CHAIN (field)))))
5533     return;
5534
5535   value = digest_init (type, value, strict_string, require_constant_value);
5536   if (value == error_mark_node)
5537     {
5538       constructor_erroneous = 1;
5539       return;
5540     }
5541
5542   /* If this element doesn't come next in sequence,
5543      put it on constructor_pending_elts.  */
5544   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5545       && (!constructor_incremental
5546           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5547     {
5548       if (constructor_incremental
5549           && tree_int_cst_lt (field, constructor_unfilled_index))
5550         set_nonincremental_init ();
5551
5552       add_pending_init (field, value);
5553       return;
5554     }
5555   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5556            && (!constructor_incremental
5557                || field != constructor_unfilled_fields))
5558     {
5559       /* We do this for records but not for unions.  In a union,
5560          no matter which field is specified, it can be initialized
5561          right away since it starts at the beginning of the union.  */
5562       if (constructor_incremental)
5563         {
5564           if (!constructor_unfilled_fields)
5565             set_nonincremental_init ();
5566           else
5567             {
5568               tree bitpos, unfillpos;
5569
5570               bitpos = bit_position (field);
5571               unfillpos = bit_position (constructor_unfilled_fields);
5572
5573               if (tree_int_cst_lt (bitpos, unfillpos))
5574                 set_nonincremental_init ();
5575             }
5576         }
5577
5578       add_pending_init (field, value);
5579       return;
5580     }
5581   else if (TREE_CODE (constructor_type) == UNION_TYPE
5582            && constructor_elements)
5583     {
5584       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5585         warning_init ("initialized field with side-effects overwritten");
5586
5587       /* We can have just one union field set.  */
5588       constructor_elements = 0;
5589     }
5590
5591   /* Otherwise, output this element either to
5592      constructor_elements or to the assembler file.  */
5593
5594   if (field && TREE_CODE (field) == INTEGER_CST)
5595     field = copy_node (field);
5596   constructor_elements
5597     = tree_cons (field, value, constructor_elements);
5598
5599   /* Advance the variable that indicates sequential elements output.  */
5600   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5601     constructor_unfilled_index
5602       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5603                     bitsize_one_node);
5604   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5605     {
5606       constructor_unfilled_fields
5607         = TREE_CHAIN (constructor_unfilled_fields);
5608
5609       /* Skip any nameless bit fields.  */
5610       while (constructor_unfilled_fields != 0
5611              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5612              && DECL_NAME (constructor_unfilled_fields) == 0)
5613         constructor_unfilled_fields =
5614           TREE_CHAIN (constructor_unfilled_fields);
5615     }
5616   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5617     constructor_unfilled_fields = 0;
5618
5619   /* Now output any pending elements which have become next.  */
5620   if (pending)
5621     output_pending_init_elements (0);
5622 }
5623
5624 /* Output any pending elements which have become next.
5625    As we output elements, constructor_unfilled_{fields,index}
5626    advances, which may cause other elements to become next;
5627    if so, they too are output.
5628
5629    If ALL is 0, we return when there are
5630    no more pending elements to output now.
5631
5632    If ALL is 1, we output space as necessary so that
5633    we can output all the pending elements.  */
5634
5635 static void
5636 output_pending_init_elements (int all)
5637 {
5638   struct init_node *elt = constructor_pending_elts;
5639   tree next;
5640
5641  retry:
5642
5643   /* Look through the whole pending tree.
5644      If we find an element that should be output now,
5645      output it.  Otherwise, set NEXT to the element
5646      that comes first among those still pending.  */
5647
5648   next = 0;
5649   while (elt)
5650     {
5651       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5652         {
5653           if (tree_int_cst_equal (elt->purpose,
5654                                   constructor_unfilled_index))
5655             output_init_element (elt->value, true,
5656                                  TREE_TYPE (constructor_type),
5657                                  constructor_unfilled_index, 0);
5658           else if (tree_int_cst_lt (constructor_unfilled_index,
5659                                     elt->purpose))
5660             {
5661               /* Advance to the next smaller node.  */
5662               if (elt->left)
5663                 elt = elt->left;
5664               else
5665                 {
5666                   /* We have reached the smallest node bigger than the
5667                      current unfilled index.  Fill the space first.  */
5668                   next = elt->purpose;
5669                   break;
5670                 }
5671             }
5672           else
5673             {
5674               /* Advance to the next bigger node.  */
5675               if (elt->right)
5676                 elt = elt->right;
5677               else
5678                 {
5679                   /* We have reached the biggest node in a subtree.  Find
5680                      the parent of it, which is the next bigger node.  */
5681                   while (elt->parent && elt->parent->right == elt)
5682                     elt = elt->parent;
5683                   elt = elt->parent;
5684                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5685                                               elt->purpose))
5686                     {
5687                       next = elt->purpose;
5688                       break;
5689                     }
5690                 }
5691             }
5692         }
5693       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5694                || TREE_CODE (constructor_type) == UNION_TYPE)
5695         {
5696           tree ctor_unfilled_bitpos, elt_bitpos;
5697
5698           /* If the current record is complete we are done.  */
5699           if (constructor_unfilled_fields == 0)
5700             break;
5701
5702           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5703           elt_bitpos = bit_position (elt->purpose);
5704           /* We can't compare fields here because there might be empty
5705              fields in between.  */
5706           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5707             {
5708               constructor_unfilled_fields = elt->purpose;
5709               output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
5710                                    elt->purpose, 0);
5711             }
5712           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5713             {
5714               /* Advance to the next smaller node.  */
5715               if (elt->left)
5716                 elt = elt->left;
5717               else
5718                 {
5719                   /* We have reached the smallest node bigger than the
5720                      current unfilled field.  Fill the space first.  */
5721                   next = elt->purpose;
5722                   break;
5723                 }
5724             }
5725           else
5726             {
5727               /* Advance to the next bigger node.  */
5728               if (elt->right)
5729                 elt = elt->right;
5730               else
5731                 {
5732                   /* We have reached the biggest node in a subtree.  Find
5733                      the parent of it, which is the next bigger node.  */
5734                   while (elt->parent && elt->parent->right == elt)
5735                     elt = elt->parent;
5736                   elt = elt->parent;
5737                   if (elt
5738                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
5739                                            bit_position (elt->purpose))))
5740                     {
5741                       next = elt->purpose;
5742                       break;
5743                     }
5744                 }
5745             }
5746         }
5747     }
5748
5749   /* Ordinarily return, but not if we want to output all
5750      and there are elements left.  */
5751   if (! (all && next != 0))
5752     return;
5753
5754   /* If it's not incremental, just skip over the gap, so that after
5755      jumping to retry we will output the next successive element.  */
5756   if (TREE_CODE (constructor_type) == RECORD_TYPE
5757       || TREE_CODE (constructor_type) == UNION_TYPE)
5758     constructor_unfilled_fields = next;
5759   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5760     constructor_unfilled_index = next;
5761
5762   /* ELT now points to the node in the pending tree with the next
5763      initializer to output.  */
5764   goto retry;
5765 }
5766 \f
5767 /* Add one non-braced element to the current constructor level.
5768    This adjusts the current position within the constructor's type.
5769    This may also start or terminate implicit levels
5770    to handle a partly-braced initializer.
5771
5772    Once this has found the correct level for the new element,
5773    it calls output_init_element.  */
5774
5775 void
5776 process_init_element (struct c_expr value)
5777 {
5778   tree orig_value = value.value;
5779   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
5780   bool strict_string = value.original_code == STRING_CST;
5781
5782   designator_depth = 0;
5783   designator_errorneous = 0;
5784
5785   /* Handle superfluous braces around string cst as in
5786      char x[] = {"foo"}; */
5787   if (string_flag
5788       && constructor_type
5789       && TREE_CODE (constructor_type) == ARRAY_TYPE
5790       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
5791       && integer_zerop (constructor_unfilled_index))
5792     {
5793       if (constructor_stack->replacement_value.value)
5794         error_init ("excess elements in char array initializer");
5795       constructor_stack->replacement_value = value;
5796       return;
5797     }
5798
5799   if (constructor_stack->replacement_value.value != 0)
5800     {
5801       error_init ("excess elements in struct initializer");
5802       return;
5803     }
5804
5805   /* Ignore elements of a brace group if it is entirely superfluous
5806      and has already been diagnosed.  */
5807   if (constructor_type == 0)
5808     return;
5809
5810   /* If we've exhausted any levels that didn't have braces,
5811      pop them now.  */
5812   while (constructor_stack->implicit)
5813     {
5814       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5815            || TREE_CODE (constructor_type) == UNION_TYPE)
5816           && constructor_fields == 0)
5817         process_init_element (pop_init_level (1));
5818       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5819                && (constructor_max_index == 0
5820                    || tree_int_cst_lt (constructor_max_index,
5821                                        constructor_index)))
5822         process_init_element (pop_init_level (1));
5823       else
5824         break;
5825     }
5826
5827   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
5828   if (constructor_range_stack)
5829     {
5830       /* If value is a compound literal and we'll be just using its
5831          content, don't put it into a SAVE_EXPR.  */
5832       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
5833           || !require_constant_value
5834           || flag_isoc99)
5835         value.value = save_expr (value.value);
5836     }
5837
5838   while (1)
5839     {
5840       if (TREE_CODE (constructor_type) == RECORD_TYPE)
5841         {
5842           tree fieldtype;
5843           enum tree_code fieldcode;
5844
5845           if (constructor_fields == 0)
5846             {
5847               pedwarn_init ("excess elements in struct initializer");
5848               break;
5849             }
5850
5851           fieldtype = TREE_TYPE (constructor_fields);
5852           if (fieldtype != error_mark_node)
5853             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5854           fieldcode = TREE_CODE (fieldtype);
5855
5856           /* Error for non-static initialization of a flexible array member.  */
5857           if (fieldcode == ARRAY_TYPE
5858               && !require_constant_value
5859               && TYPE_SIZE (fieldtype) == NULL_TREE
5860               && TREE_CHAIN (constructor_fields) == NULL_TREE)
5861             {
5862               error_init ("non-static initialization of a flexible array member");
5863               break;
5864             }
5865
5866           /* Accept a string constant to initialize a subarray.  */
5867           if (value.value != 0
5868               && fieldcode == ARRAY_TYPE
5869               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
5870               && string_flag)
5871             value.value = orig_value;
5872           /* Otherwise, if we have come to a subaggregate,
5873              and we don't have an element of its type, push into it.  */
5874           else if (value.value != 0 && !constructor_no_implicit
5875                    && value.value != error_mark_node
5876                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
5877                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5878                        || fieldcode == UNION_TYPE))
5879             {
5880               push_init_level (1);
5881               continue;
5882             }
5883
5884           if (value.value)
5885             {
5886               push_member_name (constructor_fields);
5887               output_init_element (value.value, strict_string,
5888                                    fieldtype, constructor_fields, 1);
5889               RESTORE_SPELLING_DEPTH (constructor_depth);
5890             }
5891           else
5892             /* Do the bookkeeping for an element that was
5893                directly output as a constructor.  */
5894             {
5895               /* For a record, keep track of end position of last field.  */
5896               if (DECL_SIZE (constructor_fields))
5897                 constructor_bit_index
5898                   = size_binop (PLUS_EXPR,
5899                                 bit_position (constructor_fields),
5900                                 DECL_SIZE (constructor_fields));
5901
5902               /* If the current field was the first one not yet written out,
5903                  it isn't now, so update.  */
5904               if (constructor_unfilled_fields == constructor_fields)
5905                 {
5906                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5907                   /* Skip any nameless bit fields.  */
5908                   while (constructor_unfilled_fields != 0
5909                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5910                          && DECL_NAME (constructor_unfilled_fields) == 0)
5911                     constructor_unfilled_fields =
5912                       TREE_CHAIN (constructor_unfilled_fields);
5913                 }
5914             }
5915
5916           constructor_fields = TREE_CHAIN (constructor_fields);
5917           /* Skip any nameless bit fields at the beginning.  */
5918           while (constructor_fields != 0
5919                  && DECL_C_BIT_FIELD (constructor_fields)
5920                  && DECL_NAME (constructor_fields) == 0)
5921             constructor_fields = TREE_CHAIN (constructor_fields);
5922         }
5923       else if (TREE_CODE (constructor_type) == UNION_TYPE)
5924         {
5925           tree fieldtype;
5926           enum tree_code fieldcode;
5927
5928           if (constructor_fields == 0)
5929             {
5930               pedwarn_init ("excess elements in union initializer");
5931               break;
5932             }
5933
5934           fieldtype = TREE_TYPE (constructor_fields);
5935           if (fieldtype != error_mark_node)
5936             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5937           fieldcode = TREE_CODE (fieldtype);
5938
5939           /* Warn that traditional C rejects initialization of unions.
5940              We skip the warning if the value is zero.  This is done
5941              under the assumption that the zero initializer in user
5942              code appears conditioned on e.g. __STDC__ to avoid
5943              "missing initializer" warnings and relies on default
5944              initialization to zero in the traditional C case.
5945              We also skip the warning if the initializer is designated,
5946              again on the assumption that this must be conditional on
5947              __STDC__ anyway (and we've already complained about the
5948              member-designator already).  */
5949           if (warn_traditional && !in_system_header && !constructor_designated
5950               && !(value.value && (integer_zerop (value.value)
5951                                    || real_zerop (value.value))))
5952             warning ("traditional C rejects initialization of unions");
5953
5954           /* Accept a string constant to initialize a subarray.  */
5955           if (value.value != 0
5956               && fieldcode == ARRAY_TYPE
5957               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
5958               && string_flag)
5959             value.value = orig_value;
5960           /* Otherwise, if we have come to a subaggregate,
5961              and we don't have an element of its type, push into it.  */
5962           else if (value.value != 0 && !constructor_no_implicit
5963                    && value.value != error_mark_node
5964                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
5965                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5966                        || fieldcode == UNION_TYPE))
5967             {
5968               push_init_level (1);
5969               continue;
5970             }
5971
5972           if (value.value)
5973             {
5974               push_member_name (constructor_fields);
5975               output_init_element (value.value, strict_string,
5976                                    fieldtype, constructor_fields, 1);
5977               RESTORE_SPELLING_DEPTH (constructor_depth);
5978             }
5979           else
5980             /* Do the bookkeeping for an element that was
5981                directly output as a constructor.  */
5982             {
5983               constructor_bit_index = DECL_SIZE (constructor_fields);
5984               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5985             }
5986
5987           constructor_fields = 0;
5988         }
5989       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5990         {
5991           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5992           enum tree_code eltcode = TREE_CODE (elttype);
5993
5994           /* Accept a string constant to initialize a subarray.  */
5995           if (value.value != 0
5996               && eltcode == ARRAY_TYPE
5997               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
5998               && string_flag)
5999             value.value = orig_value;
6000           /* Otherwise, if we have come to a subaggregate,
6001              and we don't have an element of its type, push into it.  */
6002           else if (value.value != 0 && !constructor_no_implicit
6003                    && value.value != error_mark_node
6004                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
6005                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6006                        || eltcode == UNION_TYPE))
6007             {
6008               push_init_level (1);
6009               continue;
6010             }
6011
6012           if (constructor_max_index != 0
6013               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6014                   || integer_all_onesp (constructor_max_index)))
6015             {
6016               pedwarn_init ("excess elements in array initializer");
6017               break;
6018             }
6019
6020           /* Now output the actual element.  */
6021           if (value.value)
6022             {
6023               push_array_bounds (tree_low_cst (constructor_index, 0));
6024               output_init_element (value.value, strict_string,
6025                                    elttype, constructor_index, 1);
6026               RESTORE_SPELLING_DEPTH (constructor_depth);
6027             }
6028
6029           constructor_index
6030             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6031
6032           if (!value.value)
6033             /* If we are doing the bookkeeping for an element that was
6034                directly output as a constructor, we must update
6035                constructor_unfilled_index.  */
6036             constructor_unfilled_index = constructor_index;
6037         }
6038       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6039         {
6040           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6041
6042          /* Do a basic check of initializer size.  Note that vectors
6043             always have a fixed size derived from their type.  */
6044           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6045             {
6046               pedwarn_init ("excess elements in vector initializer");
6047               break;
6048             }
6049
6050           /* Now output the actual element.  */
6051           if (value.value)
6052             output_init_element (value.value, strict_string,
6053                                  elttype, constructor_index, 1);
6054
6055           constructor_index
6056             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6057
6058           if (!value.value)
6059             /* If we are doing the bookkeeping for an element that was
6060                directly output as a constructor, we must update
6061                constructor_unfilled_index.  */
6062             constructor_unfilled_index = constructor_index;
6063         }
6064
6065       /* Handle the sole element allowed in a braced initializer
6066          for a scalar variable.  */
6067       else if (constructor_fields == 0)
6068         {
6069           pedwarn_init ("excess elements in scalar initializer");
6070           break;
6071         }
6072       else
6073         {
6074           if (value.value)
6075             output_init_element (value.value, strict_string,
6076                                  constructor_type, NULL_TREE, 1);
6077           constructor_fields = 0;
6078         }
6079
6080       /* Handle range initializers either at this level or anywhere higher
6081          in the designator stack.  */
6082       if (constructor_range_stack)
6083         {
6084           struct constructor_range_stack *p, *range_stack;
6085           int finish = 0;
6086
6087           range_stack = constructor_range_stack;
6088           constructor_range_stack = 0;
6089           while (constructor_stack != range_stack->stack)
6090             {
6091               if (!constructor_stack->implicit)
6092                 abort ();
6093               process_init_element (pop_init_level (1));
6094             }
6095           for (p = range_stack;
6096                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6097                p = p->prev)
6098             {
6099               if (!constructor_stack->implicit)
6100                 abort ();
6101               process_init_element (pop_init_level (1));
6102             }
6103
6104           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6105           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6106             finish = 1;
6107
6108           while (1)
6109             {
6110               constructor_index = p->index;
6111               constructor_fields = p->fields;
6112               if (finish && p->range_end && p->index == p->range_start)
6113                 {
6114                   finish = 0;
6115                   p->prev = 0;
6116                 }
6117               p = p->next;
6118               if (!p)
6119                 break;
6120               push_init_level (2);
6121               p->stack = constructor_stack;
6122               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6123                 p->index = p->range_start;
6124             }
6125
6126           if (!finish)
6127             constructor_range_stack = range_stack;
6128           continue;
6129         }
6130
6131       break;
6132     }
6133
6134   constructor_range_stack = 0;
6135 }
6136 \f
6137 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6138    (guaranteed to be 'volatile' or null) and ARGS (represented using
6139    an ASM_EXPR node).  */
6140 tree
6141 build_asm_stmt (tree cv_qualifier, tree args)
6142 {
6143   if (!ASM_VOLATILE_P (args) && cv_qualifier)
6144     ASM_VOLATILE_P (args) = 1;
6145   return add_stmt (args);
6146 }
6147
6148 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6149    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
6150    SIMPLE indicates whether there was anything at all after the
6151    string in the asm expression -- asm("blah") and asm("blah" : )
6152    are subtly different.  We use a ASM_EXPR node to represent this.  */
6153 tree
6154 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6155                 bool simple)
6156 {
6157   tree tail;
6158   tree args;
6159   int i;
6160   const char *constraint;
6161   bool allows_mem, allows_reg, is_inout;
6162   int ninputs;
6163   int noutputs;
6164
6165   ninputs = list_length (inputs);
6166   noutputs = list_length (outputs);
6167
6168   /* Remove output conversions that change the type but not the mode.  */
6169   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
6170     {
6171       tree output = TREE_VALUE (tail);
6172       STRIP_NOPS (output);
6173       TREE_VALUE (tail) = output;
6174       lvalue_or_else (output, "invalid lvalue in asm statement");
6175
6176       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6177
6178       if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
6179                                     &allows_mem, &allows_reg, &is_inout))
6180         {
6181           /* By marking this operand as erroneous, we will not try
6182           to process this operand again in expand_asm_operands.  */
6183           TREE_VALUE (tail) = error_mark_node;
6184           continue;
6185         }
6186
6187       /* If the operand is a DECL that is going to end up in
6188         memory, assume it is addressable.  This is a bit more
6189         conservative than it would ideally be; the exact test is
6190         buried deep in expand_asm_operands and depends on the
6191         DECL_RTL for the OPERAND -- which we don't have at this
6192         point.  */
6193       if (!allows_reg && DECL_P (output))
6194         c_mark_addressable (output);
6195     }
6196
6197   /* Perform default conversions on array and function inputs.
6198      Don't do this for other types as it would screw up operands
6199      expected to be in memory.  */
6200   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6201     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6202
6203   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
6204
6205   /* Simple asm statements are treated as volatile.  */
6206   if (simple)
6207     {
6208       ASM_VOLATILE_P (args) = 1;
6209       ASM_INPUT_P (args) = 1;
6210     }
6211   return args;
6212 }
6213 \f
6214 /* Generate a goto statement to LABEL.  */
6215
6216 tree
6217 c_finish_goto_label (tree label)
6218 {
6219   tree decl = lookup_label (label);
6220   if (!decl)
6221     return NULL_TREE;
6222
6223   TREE_USED (decl) = 1;
6224   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
6225 }
6226
6227 /* Generate a computed goto statement to EXPR.  */
6228
6229 tree
6230 c_finish_goto_ptr (tree expr)
6231 {
6232   if (pedantic)
6233     pedwarn ("ISO C forbids `goto *expr;'");
6234   expr = convert (ptr_type_node, expr);
6235   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
6236 }
6237
6238 /* Generate a C `return' statement.  RETVAL is the expression for what
6239    to return, or a null pointer for `return;' with no value.  */
6240
6241 tree
6242 c_finish_return (tree retval)
6243 {
6244   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6245
6246   if (TREE_THIS_VOLATILE (current_function_decl))
6247     warning ("function declared `noreturn' has a `return' statement");
6248
6249   if (!retval)
6250     {
6251       current_function_returns_null = 1;
6252       if ((warn_return_type || flag_isoc99)
6253           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6254         pedwarn_c99 ("`return' with no value, in function returning non-void");
6255     }
6256   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6257     {
6258       current_function_returns_null = 1;
6259       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6260         pedwarn ("`return' with a value, in function returning void");
6261     }
6262   else
6263     {
6264       tree t = convert_for_assignment (valtype, retval, _("return"),
6265                                        NULL_TREE, NULL_TREE, 0);
6266       tree res = DECL_RESULT (current_function_decl);
6267       tree inner;
6268
6269       current_function_returns_value = 1;
6270       if (t == error_mark_node)
6271         return NULL_TREE;
6272
6273       inner = t = convert (TREE_TYPE (res), t);
6274
6275       /* Strip any conversions, additions, and subtractions, and see if
6276          we are returning the address of a local variable.  Warn if so.  */
6277       while (1)
6278         {
6279           switch (TREE_CODE (inner))
6280             {
6281             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6282             case PLUS_EXPR:
6283               inner = TREE_OPERAND (inner, 0);
6284               continue;
6285
6286             case MINUS_EXPR:
6287               /* If the second operand of the MINUS_EXPR has a pointer
6288                  type (or is converted from it), this may be valid, so
6289                  don't give a warning.  */
6290               {
6291                 tree op1 = TREE_OPERAND (inner, 1);
6292
6293                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6294                        && (TREE_CODE (op1) == NOP_EXPR
6295                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6296                            || TREE_CODE (op1) == CONVERT_EXPR))
6297                   op1 = TREE_OPERAND (op1, 0);
6298
6299                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6300                   break;
6301
6302                 inner = TREE_OPERAND (inner, 0);
6303                 continue;
6304               }
6305
6306             case ADDR_EXPR:
6307               inner = TREE_OPERAND (inner, 0);
6308
6309               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6310                 inner = TREE_OPERAND (inner, 0);
6311
6312               if (DECL_P (inner)
6313                   && ! DECL_EXTERNAL (inner)
6314                   && ! TREE_STATIC (inner)
6315                   && DECL_CONTEXT (inner) == current_function_decl)
6316                 warning ("function returns address of local variable");
6317               break;
6318
6319             default:
6320               break;
6321             }
6322
6323           break;
6324         }
6325
6326       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
6327     }
6328
6329   return add_stmt (build_stmt (RETURN_EXPR, retval));
6330 }
6331 \f
6332 struct c_switch {
6333   /* The SWITCH_STMT being built.  */
6334   tree switch_stmt;
6335
6336   /* The original type of the testing expression, ie. before the
6337      default conversion is applied.  */
6338   tree orig_type;
6339
6340   /* A splay-tree mapping the low element of a case range to the high
6341      element, or NULL_TREE if there is no high element.  Used to
6342      determine whether or not a new case label duplicates an old case
6343      label.  We need a tree, rather than simply a hash table, because
6344      of the GNU case range extension.  */
6345   splay_tree cases;
6346
6347   /* The next node on the stack.  */
6348   struct c_switch *next;
6349 };
6350
6351 /* A stack of the currently active switch statements.  The innermost
6352    switch statement is on the top of the stack.  There is no need to
6353    mark the stack for garbage collection because it is only active
6354    during the processing of the body of a function, and we never
6355    collect at that point.  */
6356
6357 struct c_switch *c_switch_stack;
6358
6359 /* Start a C switch statement, testing expression EXP.  Return the new
6360    SWITCH_STMT.  */
6361
6362 tree
6363 c_start_case (tree exp)
6364 {
6365   enum tree_code code;
6366   tree type, orig_type = error_mark_node;
6367   struct c_switch *cs;
6368
6369   if (exp != error_mark_node)
6370     {
6371       code = TREE_CODE (TREE_TYPE (exp));
6372       orig_type = TREE_TYPE (exp);
6373
6374       if (! INTEGRAL_TYPE_P (orig_type)
6375           && code != ERROR_MARK)
6376         {
6377           error ("switch quantity not an integer");
6378           exp = integer_zero_node;
6379         }
6380       else
6381         {
6382           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6383
6384           if (warn_traditional && !in_system_header
6385               && (type == long_integer_type_node
6386                   || type == long_unsigned_type_node))
6387             warning ("`long' switch expression not converted to `int' in ISO C");
6388
6389           exp = default_conversion (exp);
6390           type = TREE_TYPE (exp);
6391         }
6392     }
6393
6394   /* Add this new SWITCH_STMT to the stack.  */
6395   cs = XNEW (struct c_switch);
6396   cs->switch_stmt = build_stmt ((enum tree_code) SWITCH_STMT, exp, NULL_TREE,
6397                                 orig_type);
6398   cs->orig_type = orig_type;
6399   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6400   cs->next = c_switch_stack;
6401   c_switch_stack = cs;
6402
6403   return add_stmt (cs->switch_stmt);
6404 }
6405
6406 /* Process a case label.  */
6407
6408 tree
6409 do_case (tree low_value, tree high_value)
6410 {
6411   tree label = NULL_TREE;
6412
6413   if (c_switch_stack)
6414     {
6415       label = c_add_case_label (c_switch_stack->cases,
6416                                 SWITCH_COND (c_switch_stack->switch_stmt),
6417                                 c_switch_stack->orig_type,
6418                                 low_value, high_value);
6419       if (label == error_mark_node)
6420         label = NULL_TREE;
6421     }
6422   else if (low_value)
6423     error ("case label not within a switch statement");
6424   else
6425     error ("`default' label not within a switch statement");
6426
6427   return label;
6428 }
6429
6430 /* Finish the switch statement.  */
6431
6432 void
6433 c_finish_case (tree body)
6434 {
6435   struct c_switch *cs = c_switch_stack;
6436
6437   SWITCH_BODY (cs->switch_stmt) = body;
6438
6439   /* Emit warnings as needed.  */
6440   c_do_switch_warnings (cs->cases, cs->switch_stmt);
6441
6442   /* Pop the stack.  */
6443   c_switch_stack = cs->next;
6444   splay_tree_delete (cs->cases);
6445   XDELETE (cs);
6446 }
6447 \f
6448 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
6449    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6450    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
6451    statement, and was not surrounded with parenthesis.  */
6452
6453 void
6454 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
6455                   tree else_block, bool nested_if)
6456 {
6457   tree stmt;
6458
6459   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
6460   if (warn_parentheses && nested_if && else_block == NULL)
6461     {
6462       tree inner_if = then_block;
6463
6464       /* We know from the grammar productions that there is an IF nested
6465          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
6466          it might not be exactly THEN_BLOCK, but should be the last
6467          non-container statement within.  */
6468       while (1)
6469         switch (TREE_CODE (inner_if))
6470           {
6471           case COND_EXPR:
6472             goto found;
6473           case BIND_EXPR:
6474             inner_if = BIND_EXPR_BODY (inner_if);
6475             break;
6476           case STATEMENT_LIST:
6477             inner_if = expr_last (then_block);
6478             break;
6479           case TRY_FINALLY_EXPR:
6480           case TRY_CATCH_EXPR:
6481             inner_if = TREE_OPERAND (inner_if, 0);
6482             break;
6483           default:
6484             abort ();
6485           }
6486     found:
6487
6488       if (COND_EXPR_ELSE (inner_if))
6489          warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
6490                   &if_locus);
6491     }
6492
6493   /* Diagnose ";" via the special empty statement node that we create.  */
6494   if (extra_warnings)
6495     {
6496       if (TREE_CODE (then_block) == NOP_EXPR && !TREE_TYPE (then_block))
6497         {
6498           if (!else_block)
6499             warning ("%Hempty body in an if-statement",
6500                      EXPR_LOCUS (then_block));
6501           then_block = alloc_stmt_list ();
6502         }
6503       if (else_block
6504           && TREE_CODE (else_block) == NOP_EXPR
6505           && !TREE_TYPE (else_block))
6506         {
6507           warning ("%Hempty body in an else-statement",
6508                    EXPR_LOCUS (else_block));
6509           else_block = alloc_stmt_list ();
6510         }
6511     }
6512
6513   stmt = build3 (COND_EXPR, NULL_TREE, cond, then_block, else_block);
6514   SET_EXPR_LOCATION (stmt, if_locus);
6515   add_stmt (stmt);
6516 }
6517
6518 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
6519    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
6520    is false for DO loops.  INCR is the FOR increment expression.  BODY is
6521    the statement controlled by the loop.  BLAB is the break label.  CLAB is
6522    the continue label.  Everything is allowed to be NULL.  */
6523
6524 void
6525 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
6526                tree blab, tree clab, bool cond_is_first)
6527 {
6528   tree entry = NULL, exit = NULL, t;
6529
6530   /* Detect do { ... } while (0) and don't generate loop construct.  */
6531   if (cond && !cond_is_first && integer_zerop (cond))
6532     cond = NULL;
6533   if (cond_is_first || cond)
6534     {
6535       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6536
6537       /* If we have an exit condition, then we build an IF with gotos either
6538          out of the loop, or to the top of it.  If there's no exit condition,
6539          then we just build a jump back to the top.  */
6540       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
6541
6542       if (cond)
6543         {
6544           /* Canonicalize the loop condition to the end.  This means
6545              generating a branch to the loop condition.  Reuse the
6546              continue label, if possible.  */
6547           if (cond_is_first)
6548             {
6549               if (incr || !clab)
6550                 {
6551                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6552                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
6553                 }
6554               else
6555                 t = build1 (GOTO_EXPR, void_type_node, clab);
6556               SET_EXPR_LOCATION (t, start_locus);
6557               add_stmt (t);
6558             }
6559
6560           t = build_and_jump (&blab);
6561           exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
6562           exit = fold (exit);
6563           if (cond_is_first)
6564             SET_EXPR_LOCATION (exit, start_locus);
6565           else
6566             SET_EXPR_LOCATION (exit, input_location);
6567         }
6568
6569       add_stmt (top);
6570     }
6571
6572   if (body)
6573     add_stmt (body);
6574   if (clab)
6575     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
6576   if (incr)
6577     add_stmt (incr);
6578   if (entry)
6579     add_stmt (entry);
6580   if (exit)
6581     add_stmt (exit);
6582   if (blab)
6583     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
6584 }
6585
6586 tree
6587 c_finish_bc_stmt (tree *label_p, bool is_break)
6588 {
6589   tree label = *label_p;
6590
6591   if (!label)
6592     *label_p = label = create_artificial_label ();
6593   else if (TREE_CODE (label) != LABEL_DECL)
6594     {
6595       if (is_break)
6596         error ("break statement not within loop or switch");
6597       else
6598         error ("continue statement not within a loop");
6599       return NULL_TREE;
6600     }
6601
6602   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
6603 }
6604
6605 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
6606
6607 static void
6608 emit_side_effect_warnings (tree expr)
6609 {
6610   if (expr == error_mark_node)
6611     ;
6612   else if (!TREE_SIDE_EFFECTS (expr))
6613     {
6614       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
6615         warning ("%Hstatement with no effect",
6616                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
6617     }
6618   else if (warn_unused_value)
6619     warn_if_unused_value (expr, input_location);
6620 }
6621
6622 /* Process an expression as if it were a complete statement.  Emit
6623    diagnostics, but do not call ADD_STMT.  */
6624
6625 tree
6626 c_process_expr_stmt (tree expr)
6627 {
6628   if (!expr)
6629     return NULL_TREE;
6630
6631   /* Do default conversion if safe and possibly important,
6632      in case within ({...}).  */
6633   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
6634        && (flag_isoc99 || lvalue_p (expr)))
6635       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
6636     expr = default_conversion (expr);
6637
6638   if (warn_sequence_point)
6639     verify_sequence_points (expr);
6640
6641   if (TREE_TYPE (expr) != error_mark_node
6642       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
6643       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
6644     error ("expression statement has incomplete type");
6645
6646   /* If we're not processing a statement expression, warn about unused values.
6647      Warnings for statement expressions will be emitted later, once we figure
6648      out which is the result.  */
6649   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6650       && (extra_warnings || warn_unused_value))
6651     emit_side_effect_warnings (expr);
6652
6653   /* If the expression is not of a type to which we cannot assign a line
6654      number, wrap the thing in a no-op NOP_EXPR.  */
6655   if (DECL_P (expr) || TREE_CODE_CLASS (TREE_CODE (expr)) == 'c')
6656     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
6657
6658   if (EXPR_P (expr))
6659     SET_EXPR_LOCATION (expr, input_location);
6660
6661   return expr;
6662 }
6663
6664 /* Emit an expression as a statement.  */
6665
6666 tree
6667 c_finish_expr_stmt (tree expr)
6668 {
6669   if (expr)
6670     return add_stmt (c_process_expr_stmt (expr));
6671   else
6672     return NULL;
6673 }
6674
6675 /* Do the opposite and emit a statement as an expression.  To begin,
6676    create a new binding level and return it.  */
6677
6678 tree
6679 c_begin_stmt_expr (void)
6680 {
6681   tree ret;
6682
6683   /* We must force a BLOCK for this level so that, if it is not expanded
6684      later, there is a way to turn off the entire subtree of blocks that
6685      are contained in it.  */
6686   keep_next_level ();
6687   ret = c_begin_compound_stmt (true);
6688
6689   /* Mark the current statement list as belonging to a statement list.  */
6690   STATEMENT_LIST_STMT_EXPR (ret) = 1;
6691
6692   return ret;
6693 }
6694
6695 tree
6696 c_finish_stmt_expr (tree body)
6697 {
6698   tree last, type, tmp, val;
6699   tree *last_p;
6700
6701   body = c_end_compound_stmt (body, true);
6702
6703   /* Locate the last statement in BODY.  See c_end_compound_stmt
6704      about always returning a BIND_EXPR.  */
6705   last_p = &BIND_EXPR_BODY (body);
6706   last = BIND_EXPR_BODY (body);
6707
6708  continue_searching:
6709   if (TREE_CODE (last) == STATEMENT_LIST)
6710     {
6711       tree_stmt_iterator i;
6712
6713       /* This can happen with degenerate cases like ({ }).  No value.  */
6714       if (!TREE_SIDE_EFFECTS (last))
6715         return body;
6716
6717       /* If we're supposed to generate side effects warnings, process
6718          all of the statements except the last.  */
6719       if (extra_warnings || warn_unused_value)
6720         {
6721           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
6722             emit_side_effect_warnings (tsi_stmt (i));
6723         }
6724       else
6725         i = tsi_last (last);
6726       last_p = tsi_stmt_ptr (i);
6727       last = *last_p;
6728     }
6729
6730   /* If the end of the list is exception related, then the list was split
6731      by a call to push_cleanup.  Continue searching.  */
6732   if (TREE_CODE (last) == TRY_FINALLY_EXPR
6733       || TREE_CODE (last) == TRY_CATCH_EXPR)
6734     {
6735       last_p = &TREE_OPERAND (last, 0);
6736       last = *last_p;
6737       goto continue_searching;
6738     }
6739
6740   /* In the case that the BIND_EXPR is not necessary, return the
6741      expression out from inside it.  */
6742   if (last == error_mark_node
6743       || (last == BIND_EXPR_BODY (body)
6744           && BIND_EXPR_VARS (body) == NULL))
6745     return last;
6746
6747   /* Extract the type of said expression.  */
6748   type = TREE_TYPE (last);
6749
6750   /* If we're not returning a value at all, then the BIND_EXPR that
6751      we already have is a fine expression to return.  */
6752   if (!type || VOID_TYPE_P (type))
6753     return body;
6754
6755   /* Now that we've located the expression containing the value, it seems
6756      silly to make voidify_wrapper_expr repeat the process.  Create a
6757      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
6758   tmp = create_tmp_var_raw (type, NULL);
6759
6760   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
6761      tree_expr_nonnegative_p giving up immediately.  */
6762   val = last;
6763   if (TREE_CODE (val) == NOP_EXPR
6764       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
6765     val = TREE_OPERAND (val, 0);
6766
6767   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
6768   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
6769
6770   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
6771 }
6772 \f
6773 /* Begin and end compound statements.  This is as simple as pushing
6774    and popping new statement lists from the tree.  */
6775
6776 tree
6777 c_begin_compound_stmt (bool do_scope)
6778 {
6779   tree stmt = push_stmt_list ();
6780   if (do_scope)
6781     push_scope ();
6782   return stmt;
6783 }
6784
6785 tree
6786 c_end_compound_stmt (tree stmt, bool do_scope)
6787 {
6788   tree block = NULL;
6789
6790   if (do_scope)
6791     {
6792       if (c_dialect_objc ())
6793         objc_clear_super_receiver ();
6794       block = pop_scope ();
6795     }
6796
6797   stmt = pop_stmt_list (stmt);
6798   stmt = c_build_bind_expr (block, stmt);
6799
6800   /* If this compound statement is nested immediately inside a statement
6801      expression, then force a BIND_EXPR to be created.  Otherwise we'll
6802      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
6803      STATEMENT_LISTs merge, and thus we can lose track of what statement
6804      was really last.  */
6805   if (cur_stmt_list
6806       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6807       && TREE_CODE (stmt) != BIND_EXPR)
6808     {
6809       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
6810       TREE_SIDE_EFFECTS (stmt) = 1;
6811     }
6812
6813   return stmt;
6814 }
6815
6816 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
6817    when the current scope is exited.  EH_ONLY is true when this is not
6818    meant to apply to normal control flow transfer.  */
6819
6820 void
6821 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
6822 {
6823   enum tree_code code;
6824   tree stmt, list;
6825   bool stmt_expr;
6826
6827   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
6828   stmt = build_stmt (code, NULL, cleanup);
6829   add_stmt (stmt);
6830   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
6831   list = push_stmt_list ();
6832   TREE_OPERAND (stmt, 0) = list;
6833   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
6834 }
6835 \f
6836 /* Build a binary-operation expression without default conversions.
6837    CODE is the kind of expression to build.
6838    This function differs from `build' in several ways:
6839    the data type of the result is computed and recorded in it,
6840    warnings are generated if arg data types are invalid,
6841    special handling for addition and subtraction of pointers is known,
6842    and some optimization is done (operations on narrow ints
6843    are done in the narrower type when that gives the same result).
6844    Constant folding is also done before the result is returned.
6845
6846    Note that the operands will never have enumeral types, or function
6847    or array types, because either they will have the default conversions
6848    performed or they have both just been converted to some other type in which
6849    the arithmetic is to be done.  */
6850
6851 tree
6852 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6853                  int convert_p)
6854 {
6855   tree type0, type1;
6856   enum tree_code code0, code1;
6857   tree op0, op1;
6858
6859   /* Expression code to give to the expression when it is built.
6860      Normally this is CODE, which is what the caller asked for,
6861      but in some special cases we change it.  */
6862   enum tree_code resultcode = code;
6863
6864   /* Data type in which the computation is to be performed.
6865      In the simplest cases this is the common type of the arguments.  */
6866   tree result_type = NULL;
6867
6868   /* Nonzero means operands have already been type-converted
6869      in whatever way is necessary.
6870      Zero means they need to be converted to RESULT_TYPE.  */
6871   int converted = 0;
6872
6873   /* Nonzero means create the expression with this type, rather than
6874      RESULT_TYPE.  */
6875   tree build_type = 0;
6876
6877   /* Nonzero means after finally constructing the expression
6878      convert it to this type.  */
6879   tree final_type = 0;
6880
6881   /* Nonzero if this is an operation like MIN or MAX which can
6882      safely be computed in short if both args are promoted shorts.
6883      Also implies COMMON.
6884      -1 indicates a bitwise operation; this makes a difference
6885      in the exact conditions for when it is safe to do the operation
6886      in a narrower mode.  */
6887   int shorten = 0;
6888
6889   /* Nonzero if this is a comparison operation;
6890      if both args are promoted shorts, compare the original shorts.
6891      Also implies COMMON.  */
6892   int short_compare = 0;
6893
6894   /* Nonzero if this is a right-shift operation, which can be computed on the
6895      original short and then promoted if the operand is a promoted short.  */
6896   int short_shift = 0;
6897
6898   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
6899   int common = 0;
6900
6901   if (convert_p)
6902     {
6903       op0 = default_conversion (orig_op0);
6904       op1 = default_conversion (orig_op1);
6905     }
6906   else
6907     {
6908       op0 = orig_op0;
6909       op1 = orig_op1;
6910     }
6911
6912   type0 = TREE_TYPE (op0);
6913   type1 = TREE_TYPE (op1);
6914
6915   /* The expression codes of the data types of the arguments tell us
6916      whether the arguments are integers, floating, pointers, etc.  */
6917   code0 = TREE_CODE (type0);
6918   code1 = TREE_CODE (type1);
6919
6920   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
6921   STRIP_TYPE_NOPS (op0);
6922   STRIP_TYPE_NOPS (op1);
6923
6924   /* If an error was already reported for one of the arguments,
6925      avoid reporting another error.  */
6926
6927   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6928     return error_mark_node;
6929
6930   switch (code)
6931     {
6932     case PLUS_EXPR:
6933       /* Handle the pointer + int case.  */
6934       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6935         return pointer_int_sum (PLUS_EXPR, op0, op1);
6936       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
6937         return pointer_int_sum (PLUS_EXPR, op1, op0);
6938       else
6939         common = 1;
6940       break;
6941
6942     case MINUS_EXPR:
6943       /* Subtraction of two similar pointers.
6944          We must subtract them as integers, then divide by object size.  */
6945       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
6946           && comp_target_types (type0, type1, 1))
6947         return pointer_diff (op0, op1);
6948       /* Handle pointer minus int.  Just like pointer plus int.  */
6949       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6950         return pointer_int_sum (MINUS_EXPR, op0, op1);
6951       else
6952         common = 1;
6953       break;
6954
6955     case MULT_EXPR:
6956       common = 1;
6957       break;
6958
6959     case TRUNC_DIV_EXPR:
6960     case CEIL_DIV_EXPR:
6961     case FLOOR_DIV_EXPR:
6962     case ROUND_DIV_EXPR:
6963     case EXACT_DIV_EXPR:
6964       /* Floating point division by zero is a legitimate way to obtain
6965          infinities and NaNs.  */
6966       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6967         warning ("division by zero");
6968
6969       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6970            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6971           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6972               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
6973         {
6974           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6975             code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
6976           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
6977             code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
6978
6979           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
6980             resultcode = RDIV_EXPR;
6981           else
6982             /* Although it would be tempting to shorten always here, that
6983                loses on some targets, since the modulo instruction is
6984                undefined if the quotient can't be represented in the
6985                computation mode.  We shorten only if unsigned or if
6986                dividing by something we know != -1.  */
6987             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
6988                        || (TREE_CODE (op1) == INTEGER_CST
6989                            && ! integer_all_onesp (op1)));
6990           common = 1;
6991         }
6992       break;
6993
6994     case BIT_AND_EXPR:
6995     case BIT_IOR_EXPR:
6996     case BIT_XOR_EXPR:
6997       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6998         shorten = -1;
6999       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
7000         common = 1;
7001       break;
7002
7003     case TRUNC_MOD_EXPR:
7004     case FLOOR_MOD_EXPR:
7005       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
7006         warning ("division by zero");
7007
7008       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7009         {
7010           /* Although it would be tempting to shorten always here, that loses
7011              on some targets, since the modulo instruction is undefined if the
7012              quotient can't be represented in the computation mode.  We shorten
7013              only if unsigned or if dividing by something we know != -1.  */
7014           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7015                      || (TREE_CODE (op1) == INTEGER_CST
7016                          && ! integer_all_onesp (op1)));
7017           common = 1;
7018         }
7019       break;
7020
7021     case TRUTH_ANDIF_EXPR:
7022     case TRUTH_ORIF_EXPR:
7023     case TRUTH_AND_EXPR:
7024     case TRUTH_OR_EXPR:
7025     case TRUTH_XOR_EXPR:
7026       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
7027            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
7028           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
7029               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
7030         {
7031           /* Result of these operations is always an int,
7032              but that does not mean the operands should be
7033              converted to ints!  */
7034           result_type = integer_type_node;
7035           op0 = lang_hooks.truthvalue_conversion (op0);
7036           op1 = lang_hooks.truthvalue_conversion (op1);
7037           converted = 1;
7038         }
7039       break;
7040
7041       /* Shift operations: result has same type as first operand;
7042          always convert second operand to int.
7043          Also set SHORT_SHIFT if shifting rightward.  */
7044
7045     case RSHIFT_EXPR:
7046       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7047         {
7048           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7049             {
7050               if (tree_int_cst_sgn (op1) < 0)
7051                 warning ("right shift count is negative");
7052               else
7053                 {
7054                   if (! integer_zerop (op1))
7055                     short_shift = 1;
7056
7057                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7058                     warning ("right shift count >= width of type");
7059                 }
7060             }
7061
7062           /* Use the type of the value to be shifted.  */
7063           result_type = type0;
7064           /* Convert the shift-count to an integer, regardless of size
7065              of value being shifted.  */
7066           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7067             op1 = convert (integer_type_node, op1);
7068           /* Avoid converting op1 to result_type later.  */
7069           converted = 1;
7070         }
7071       break;
7072
7073     case LSHIFT_EXPR:
7074       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7075         {
7076           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7077             {
7078               if (tree_int_cst_sgn (op1) < 0)
7079                 warning ("left shift count is negative");
7080
7081               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7082                 warning ("left shift count >= width of type");
7083             }
7084
7085           /* Use the type of the value to be shifted.  */
7086           result_type = type0;
7087           /* Convert the shift-count to an integer, regardless of size
7088              of value being shifted.  */
7089           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7090             op1 = convert (integer_type_node, op1);
7091           /* Avoid converting op1 to result_type later.  */
7092           converted = 1;
7093         }
7094       break;
7095
7096     case RROTATE_EXPR:
7097     case LROTATE_EXPR:
7098       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7099         {
7100           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7101             {
7102               if (tree_int_cst_sgn (op1) < 0)
7103                 warning ("shift count is negative");
7104               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7105                 warning ("shift count >= width of type");
7106             }
7107
7108           /* Use the type of the value to be shifted.  */
7109           result_type = type0;
7110           /* Convert the shift-count to an integer, regardless of size
7111              of value being shifted.  */
7112           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7113             op1 = convert (integer_type_node, op1);
7114           /* Avoid converting op1 to result_type later.  */
7115           converted = 1;
7116         }
7117       break;
7118
7119     case EQ_EXPR:
7120     case NE_EXPR:
7121       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
7122         warning ("comparing floating point with == or != is unsafe");
7123       /* Result of comparison is always int,
7124          but don't convert the args to int!  */
7125       build_type = integer_type_node;
7126       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7127            || code0 == COMPLEX_TYPE)
7128           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7129               || code1 == COMPLEX_TYPE))
7130         short_compare = 1;
7131       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7132         {
7133           tree tt0 = TREE_TYPE (type0);
7134           tree tt1 = TREE_TYPE (type1);
7135           /* Anything compares with void *.  void * compares with anything.
7136              Otherwise, the targets must be compatible
7137              and both must be object or both incomplete.  */
7138           if (comp_target_types (type0, type1, 1))
7139             result_type = common_pointer_type (type0, type1);
7140           else if (VOID_TYPE_P (tt0))
7141             {
7142               /* op0 != orig_op0 detects the case of something
7143                  whose value is 0 but which isn't a valid null ptr const.  */
7144               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
7145                   && TREE_CODE (tt1) == FUNCTION_TYPE)
7146                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
7147             }
7148           else if (VOID_TYPE_P (tt1))
7149             {
7150               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
7151                   && TREE_CODE (tt0) == FUNCTION_TYPE)
7152                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
7153             }
7154           else
7155             pedwarn ("comparison of distinct pointer types lacks a cast");
7156
7157           if (result_type == NULL_TREE)
7158             result_type = ptr_type_node;
7159         }
7160       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7161                && integer_zerop (op1))
7162         result_type = type0;
7163       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7164                && integer_zerop (op0))
7165         result_type = type1;
7166       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7167         {
7168           result_type = type0;
7169           pedwarn ("comparison between pointer and integer");
7170         }
7171       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7172         {
7173           result_type = type1;
7174           pedwarn ("comparison between pointer and integer");
7175         }
7176       break;
7177
7178     case MAX_EXPR:
7179     case MIN_EXPR:
7180       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7181           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7182         shorten = 1;
7183       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7184         {
7185           if (comp_target_types (type0, type1, 1))
7186             {
7187               result_type = common_pointer_type (type0, type1);
7188               if (pedantic
7189                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7190                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7191             }
7192           else
7193             {
7194               result_type = ptr_type_node;
7195               pedwarn ("comparison of distinct pointer types lacks a cast");
7196             }
7197         }
7198       break;
7199
7200     case LE_EXPR:
7201     case GE_EXPR:
7202     case LT_EXPR:
7203     case GT_EXPR:
7204       build_type = integer_type_node;
7205       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7206           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7207         short_compare = 1;
7208       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7209         {
7210           if (comp_target_types (type0, type1, 1))
7211             {
7212               result_type = common_pointer_type (type0, type1);
7213               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
7214                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
7215                 pedwarn ("comparison of complete and incomplete pointers");
7216               else if (pedantic
7217                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7218                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7219             }
7220           else
7221             {
7222               result_type = ptr_type_node;
7223               pedwarn ("comparison of distinct pointer types lacks a cast");
7224             }
7225         }
7226       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7227                && integer_zerop (op1))
7228         {
7229           result_type = type0;
7230           if (pedantic || extra_warnings)
7231             pedwarn ("ordered comparison of pointer with integer zero");
7232         }
7233       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7234                && integer_zerop (op0))
7235         {
7236           result_type = type1;
7237           if (pedantic)
7238             pedwarn ("ordered comparison of pointer with integer zero");
7239         }
7240       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7241         {
7242           result_type = type0;
7243           pedwarn ("comparison between pointer and integer");
7244         }
7245       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7246         {
7247           result_type = type1;
7248           pedwarn ("comparison between pointer and integer");
7249         }
7250       break;
7251
7252     case UNORDERED_EXPR:
7253     case ORDERED_EXPR:
7254     case UNLT_EXPR:
7255     case UNLE_EXPR:
7256     case UNGT_EXPR:
7257     case UNGE_EXPR:
7258     case UNEQ_EXPR:
7259     case LTGT_EXPR:
7260       build_type = integer_type_node;
7261       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
7262         {
7263           error ("unordered comparison on non-floating point argument");
7264           return error_mark_node;
7265         }
7266       common = 1;
7267       break;
7268
7269     default:
7270       break;
7271     }
7272
7273   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7274     return error_mark_node;
7275
7276   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
7277        || code0 == VECTOR_TYPE)
7278       &&
7279       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
7280        || code1 == VECTOR_TYPE))
7281     {
7282       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7283
7284       if (shorten || common || short_compare)
7285         result_type = common_type (type0, type1);
7286
7287       /* For certain operations (which identify themselves by shorten != 0)
7288          if both args were extended from the same smaller type,
7289          do the arithmetic in that type and then extend.
7290
7291          shorten !=0 and !=1 indicates a bitwise operation.
7292          For them, this optimization is safe only if
7293          both args are zero-extended or both are sign-extended.
7294          Otherwise, we might change the result.
7295          Eg, (short)-1 | (unsigned short)-1 is (int)-1
7296          but calculated in (unsigned short) it would be (unsigned short)-1.  */
7297
7298       if (shorten && none_complex)
7299         {
7300           int unsigned0, unsigned1;
7301           tree arg0 = get_narrower (op0, &unsigned0);
7302           tree arg1 = get_narrower (op1, &unsigned1);
7303           /* UNS is 1 if the operation to be done is an unsigned one.  */
7304           int uns = TYPE_UNSIGNED (result_type);
7305           tree type;
7306
7307           final_type = result_type;
7308
7309           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7310              but it *requires* conversion to FINAL_TYPE.  */
7311
7312           if ((TYPE_PRECISION (TREE_TYPE (op0))
7313                == TYPE_PRECISION (TREE_TYPE (arg0)))
7314               && TREE_TYPE (op0) != final_type)
7315             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
7316           if ((TYPE_PRECISION (TREE_TYPE (op1))
7317                == TYPE_PRECISION (TREE_TYPE (arg1)))
7318               && TREE_TYPE (op1) != final_type)
7319             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
7320
7321           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
7322
7323           /* For bitwise operations, signedness of nominal type
7324              does not matter.  Consider only how operands were extended.  */
7325           if (shorten == -1)
7326             uns = unsigned0;
7327
7328           /* Note that in all three cases below we refrain from optimizing
7329              an unsigned operation on sign-extended args.
7330              That would not be valid.  */
7331
7332           /* Both args variable: if both extended in same way
7333              from same width, do it in that width.
7334              Do it unsigned if args were zero-extended.  */
7335           if ((TYPE_PRECISION (TREE_TYPE (arg0))
7336                < TYPE_PRECISION (result_type))
7337               && (TYPE_PRECISION (TREE_TYPE (arg1))
7338                   == TYPE_PRECISION (TREE_TYPE (arg0)))
7339               && unsigned0 == unsigned1
7340               && (unsigned0 || !uns))
7341             result_type
7342               = c_common_signed_or_unsigned_type
7343               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7344           else if (TREE_CODE (arg0) == INTEGER_CST
7345                    && (unsigned1 || !uns)
7346                    && (TYPE_PRECISION (TREE_TYPE (arg1))
7347                        < TYPE_PRECISION (result_type))
7348                    && (type
7349                        = c_common_signed_or_unsigned_type (unsigned1,
7350                                                            TREE_TYPE (arg1)),
7351                        int_fits_type_p (arg0, type)))
7352             result_type = type;
7353           else if (TREE_CODE (arg1) == INTEGER_CST
7354                    && (unsigned0 || !uns)
7355                    && (TYPE_PRECISION (TREE_TYPE (arg0))
7356                        < TYPE_PRECISION (result_type))
7357                    && (type
7358                        = c_common_signed_or_unsigned_type (unsigned0,
7359                                                            TREE_TYPE (arg0)),
7360                        int_fits_type_p (arg1, type)))
7361             result_type = type;
7362         }
7363
7364       /* Shifts can be shortened if shifting right.  */
7365
7366       if (short_shift)
7367         {
7368           int unsigned_arg;
7369           tree arg0 = get_narrower (op0, &unsigned_arg);
7370
7371           final_type = result_type;
7372
7373           if (arg0 == op0 && final_type == TREE_TYPE (op0))
7374             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
7375
7376           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7377               /* We can shorten only if the shift count is less than the
7378                  number of bits in the smaller type size.  */
7379               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7380               /* We cannot drop an unsigned shift after sign-extension.  */
7381               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
7382             {
7383               /* Do an unsigned shift if the operand was zero-extended.  */
7384               result_type
7385                 = c_common_signed_or_unsigned_type (unsigned_arg,
7386                                                     TREE_TYPE (arg0));
7387               /* Convert value-to-be-shifted to that type.  */
7388               if (TREE_TYPE (op0) != result_type)
7389                 op0 = convert (result_type, op0);
7390               converted = 1;
7391             }
7392         }
7393
7394       /* Comparison operations are shortened too but differently.
7395          They identify themselves by setting short_compare = 1.  */
7396
7397       if (short_compare)
7398         {
7399           /* Don't write &op0, etc., because that would prevent op0
7400              from being kept in a register.
7401              Instead, make copies of the our local variables and
7402              pass the copies by reference, then copy them back afterward.  */
7403           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7404           enum tree_code xresultcode = resultcode;
7405           tree val
7406             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7407
7408           if (val != 0)
7409             return val;
7410
7411           op0 = xop0, op1 = xop1;
7412           converted = 1;
7413           resultcode = xresultcode;
7414
7415           if (warn_sign_compare && skip_evaluation == 0)
7416             {
7417               int op0_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op0));
7418               int op1_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op1));
7419               int unsignedp0, unsignedp1;
7420               tree primop0 = get_narrower (op0, &unsignedp0);
7421               tree primop1 = get_narrower (op1, &unsignedp1);
7422
7423               xop0 = orig_op0;
7424               xop1 = orig_op1;
7425               STRIP_TYPE_NOPS (xop0);
7426               STRIP_TYPE_NOPS (xop1);
7427
7428               /* Give warnings for comparisons between signed and unsigned
7429                  quantities that may fail.
7430
7431                  Do the checking based on the original operand trees, so that
7432                  casts will be considered, but default promotions won't be.
7433
7434                  Do not warn if the comparison is being done in a signed type,
7435                  since the signed type will only be chosen if it can represent
7436                  all the values of the unsigned type.  */
7437               if (! TYPE_UNSIGNED (result_type))
7438                 /* OK */;
7439               /* Do not warn if both operands are the same signedness.  */
7440               else if (op0_signed == op1_signed)
7441                 /* OK */;
7442               else
7443                 {
7444                   tree sop, uop;
7445
7446                   if (op0_signed)
7447                     sop = xop0, uop = xop1;
7448                   else
7449                     sop = xop1, uop = xop0;
7450
7451                   /* Do not warn if the signed quantity is an
7452                      unsuffixed integer literal (or some static
7453                      constant expression involving such literals or a
7454                      conditional expression involving such literals)
7455                      and it is non-negative.  */
7456                   if (tree_expr_nonnegative_p (sop))
7457                     /* OK */;
7458                   /* Do not warn if the comparison is an equality operation,
7459                      the unsigned quantity is an integral constant, and it
7460                      would fit in the result if the result were signed.  */
7461                   else if (TREE_CODE (uop) == INTEGER_CST
7462                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7463                            && int_fits_type_p
7464                            (uop, c_common_signed_type (result_type)))
7465                     /* OK */;
7466                   /* Do not warn if the unsigned quantity is an enumeration
7467                      constant and its maximum value would fit in the result
7468                      if the result were signed.  */
7469                   else if (TREE_CODE (uop) == INTEGER_CST
7470                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7471                            && int_fits_type_p
7472                            (TYPE_MAX_VALUE (TREE_TYPE(uop)),
7473                             c_common_signed_type (result_type)))
7474                     /* OK */;
7475                   else
7476                     warning ("comparison between signed and unsigned");
7477                 }
7478
7479               /* Warn if two unsigned values are being compared in a size
7480                  larger than their original size, and one (and only one) is the
7481                  result of a `~' operator.  This comparison will always fail.
7482
7483                  Also warn if one operand is a constant, and the constant
7484                  does not have all bits set that are set in the ~ operand
7485                  when it is extended.  */
7486
7487               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7488                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7489                 {
7490                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7491                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7492                                             &unsignedp0);
7493                   else
7494                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7495                                             &unsignedp1);
7496
7497                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7498                     {
7499                       tree primop;
7500                       HOST_WIDE_INT constant, mask;
7501                       int unsignedp, bits;
7502
7503                       if (host_integerp (primop0, 0))
7504                         {
7505                           primop = primop1;
7506                           unsignedp = unsignedp1;
7507                           constant = tree_low_cst (primop0, 0);
7508                         }
7509                       else
7510                         {
7511                           primop = primop0;
7512                           unsignedp = unsignedp0;
7513                           constant = tree_low_cst (primop1, 0);
7514                         }
7515
7516                       bits = TYPE_PRECISION (TREE_TYPE (primop));
7517                       if (bits < TYPE_PRECISION (result_type)
7518                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7519                         {
7520                           mask = (~ (HOST_WIDE_INT) 0) << bits;
7521                           if ((mask & constant) != mask)
7522                             warning ("comparison of promoted ~unsigned with constant");
7523                         }
7524                     }
7525                   else if (unsignedp0 && unsignedp1
7526                            && (TYPE_PRECISION (TREE_TYPE (primop0))
7527                                < TYPE_PRECISION (result_type))
7528                            && (TYPE_PRECISION (TREE_TYPE (primop1))
7529                                < TYPE_PRECISION (result_type)))
7530                     warning ("comparison of promoted ~unsigned with unsigned");
7531                 }
7532             }
7533         }
7534     }
7535
7536   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7537      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7538      Then the expression will be built.
7539      It will be given type FINAL_TYPE if that is nonzero;
7540      otherwise, it will be given type RESULT_TYPE.  */
7541
7542   if (!result_type)
7543     {
7544       binary_op_error (code);
7545       return error_mark_node;
7546     }
7547
7548   if (! converted)
7549     {
7550       if (TREE_TYPE (op0) != result_type)
7551         op0 = convert (result_type, op0);
7552       if (TREE_TYPE (op1) != result_type)
7553         op1 = convert (result_type, op1);
7554
7555       /* This can happen if one operand has a vector type, and the other
7556          has a different type.  */
7557       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
7558         return error_mark_node;
7559     }
7560
7561   if (build_type == NULL_TREE)
7562     build_type = result_type;
7563
7564   {
7565     tree result = build2 (resultcode, build_type, op0, op1);
7566
7567     /* Treat expressions in initializers specially as they can't trap.  */
7568     result = require_constant_value ? fold_initializer (result)
7569                                     : fold (result);
7570
7571     if (final_type != 0)
7572       result = convert (final_type, result);
7573     return result;
7574   }
7575 }
7576
7577 /* Build the result of __builtin_offsetof.  TYPE is the first argument to
7578    offsetof, i.e. a type.  LIST is a tree_list that encodes component and
7579    array references; PURPOSE is set for the former and VALUE is set for
7580    the later.  */
7581
7582 tree
7583 build_offsetof (tree type, tree list)
7584 {
7585   tree t;
7586
7587   /* Build "*(type *)0".  */
7588   t = convert (build_pointer_type (type), null_pointer_node);
7589   t = build_indirect_ref (t, "");
7590
7591   /* Build COMPONENT and ARRAY_REF expressions as needed.  */
7592   for (list = nreverse (list); list ; list = TREE_CHAIN (list))
7593     if (TREE_PURPOSE (list))
7594       t = build_component_ref (t, TREE_PURPOSE (list));
7595     else
7596       t = build_array_ref (t, TREE_VALUE (list));
7597
7598   /* Finalize the offsetof expression.  For now all we need to do is take
7599      the address of the expression we created, and cast that to an integer
7600      type; this mirrors the traditional macro implementation of offsetof.  */
7601   t = build_unary_op (ADDR_EXPR, t, 0);
7602   return convert (size_type_node, t);
7603 }