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       if (!c_mark_addressable (arg))
2518         return error_mark_node;
2519
2520       if (TREE_CODE (arg) == COMPONENT_REF
2521           && DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
2522         {
2523           error ("attempt to take address of bit-field structure member `%D'",
2524                  TREE_OPERAND (arg, 1));
2525           return error_mark_node;
2526         }
2527
2528       argtype = build_pointer_type (argtype);
2529       val = build1 (ADDR_EXPR, argtype, arg);
2530
2531       if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
2532         TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
2533
2534       return val;
2535
2536     default:
2537       break;
2538     }
2539
2540   if (argtype == 0)
2541     argtype = TREE_TYPE (arg);
2542   val = build1 (code, argtype, arg);
2543   return require_constant_value ? fold_initializer (val) : fold (val);
2544 }
2545
2546 /* Return nonzero if REF is an lvalue valid for this language.
2547    Lvalues can be assigned, unless their type has TYPE_READONLY.
2548    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
2549
2550 int
2551 lvalue_p (tree ref)
2552 {
2553   enum tree_code code = TREE_CODE (ref);
2554
2555   switch (code)
2556     {
2557     case REALPART_EXPR:
2558     case IMAGPART_EXPR:
2559     case COMPONENT_REF:
2560       return lvalue_p (TREE_OPERAND (ref, 0));
2561
2562     case COMPOUND_LITERAL_EXPR:
2563     case STRING_CST:
2564       return 1;
2565
2566     case INDIRECT_REF:
2567     case ARRAY_REF:
2568     case VAR_DECL:
2569     case PARM_DECL:
2570     case RESULT_DECL:
2571     case ERROR_MARK:
2572       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2573               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2574
2575     case BIND_EXPR:
2576       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2577
2578     default:
2579       return 0;
2580     }
2581 }
2582
2583 /* Return nonzero if REF is an lvalue valid for this language;
2584    otherwise, print an error message and return zero.  */
2585
2586 static int
2587 lvalue_or_else (tree ref, const char *msgid)
2588 {
2589   int win = lvalue_p (ref);
2590
2591   if (! win)
2592     error ("%s", msgid);
2593
2594   return win;
2595 }
2596
2597 \f
2598 /* Warn about storing in something that is `const'.  */
2599
2600 void
2601 readonly_error (tree arg, const char *msgid)
2602 {
2603   if (TREE_CODE (arg) == COMPONENT_REF)
2604     {
2605       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2606         readonly_error (TREE_OPERAND (arg, 0), msgid);
2607       else
2608         error ("%s of read-only member `%s'", _(msgid),
2609                IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
2610     }
2611   else if (TREE_CODE (arg) == VAR_DECL)
2612     error ("%s of read-only variable `%s'", _(msgid),
2613            IDENTIFIER_POINTER (DECL_NAME (arg)));
2614   else
2615     error ("%s of read-only location", _(msgid));
2616 }
2617 \f
2618 /* Mark EXP saying that we need to be able to take the
2619    address of it; it should not be allocated in a register.
2620    Returns true if successful.  */
2621
2622 bool
2623 c_mark_addressable (tree exp)
2624 {
2625   tree x = exp;
2626
2627   while (1)
2628     switch (TREE_CODE (x))
2629       {
2630       case COMPONENT_REF:
2631         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2632           {
2633             error ("cannot take address of bit-field `%s'",
2634                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
2635             return false;
2636           }
2637
2638         /* ... fall through ...  */
2639
2640       case ADDR_EXPR:
2641       case ARRAY_REF:
2642       case REALPART_EXPR:
2643       case IMAGPART_EXPR:
2644         x = TREE_OPERAND (x, 0);
2645         break;
2646
2647       case COMPOUND_LITERAL_EXPR:
2648       case CONSTRUCTOR:
2649         TREE_ADDRESSABLE (x) = 1;
2650         return true;
2651
2652       case VAR_DECL:
2653       case CONST_DECL:
2654       case PARM_DECL:
2655       case RESULT_DECL:
2656         if (C_DECL_REGISTER (x)
2657             && DECL_NONLOCAL (x))
2658           {
2659             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2660               {
2661                 error ("global register variable `%s' used in nested function",
2662                        IDENTIFIER_POINTER (DECL_NAME (x)));
2663                 return false;
2664               }
2665             pedwarn ("register variable `%s' used in nested function",
2666                      IDENTIFIER_POINTER (DECL_NAME (x)));
2667           }
2668         else if (C_DECL_REGISTER (x))
2669           {
2670             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2671               {
2672                 error ("address of global register variable `%s' requested",
2673                        IDENTIFIER_POINTER (DECL_NAME (x)));
2674                 return false;
2675               }
2676
2677             pedwarn ("address of register variable `%s' requested",
2678                      IDENTIFIER_POINTER (DECL_NAME (x)));
2679           }
2680
2681         /* drops in */
2682       case FUNCTION_DECL:
2683         TREE_ADDRESSABLE (x) = 1;
2684         /* drops out */
2685       default:
2686         return true;
2687     }
2688 }
2689 \f
2690 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
2691
2692 tree
2693 build_conditional_expr (tree ifexp, tree op1, tree op2)
2694 {
2695   tree type1;
2696   tree type2;
2697   enum tree_code code1;
2698   enum tree_code code2;
2699   tree result_type = NULL;
2700   tree orig_op1 = op1, orig_op2 = op2;
2701
2702   ifexp = lang_hooks.truthvalue_conversion (default_conversion (ifexp));
2703
2704   /* Promote both alternatives.  */
2705
2706   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2707     op1 = default_conversion (op1);
2708   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2709     op2 = default_conversion (op2);
2710
2711   if (TREE_CODE (ifexp) == ERROR_MARK
2712       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2713       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2714     return error_mark_node;
2715
2716   type1 = TREE_TYPE (op1);
2717   code1 = TREE_CODE (type1);
2718   type2 = TREE_TYPE (op2);
2719   code2 = TREE_CODE (type2);
2720
2721   /* C90 does not permit non-lvalue arrays in conditional expressions.
2722      In C99 they will be pointers by now.  */
2723   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
2724     {
2725       error ("non-lvalue array in conditional expression");
2726       return error_mark_node;
2727     }
2728
2729   /* Quickly detect the usual case where op1 and op2 have the same type
2730      after promotion.  */
2731   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2732     {
2733       if (type1 == type2)
2734         result_type = type1;
2735       else
2736         result_type = TYPE_MAIN_VARIANT (type1);
2737     }
2738   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2739             || code1 == COMPLEX_TYPE)
2740            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2741                || code2 == COMPLEX_TYPE))
2742     {
2743       result_type = common_type (type1, type2);
2744
2745       /* If -Wsign-compare, warn here if type1 and type2 have
2746          different signedness.  We'll promote the signed to unsigned
2747          and later code won't know it used to be different.
2748          Do this check on the original types, so that explicit casts
2749          will be considered, but default promotions won't.  */
2750       if (warn_sign_compare && !skip_evaluation)
2751         {
2752           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
2753           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
2754
2755           if (unsigned_op1 ^ unsigned_op2)
2756             {
2757               /* Do not warn if the result type is signed, since the
2758                  signed type will only be chosen if it can represent
2759                  all the values of the unsigned type.  */
2760               if (! TYPE_UNSIGNED (result_type))
2761                 /* OK */;
2762               /* Do not warn if the signed quantity is an unsuffixed
2763                  integer literal (or some static constant expression
2764                  involving such literals) and it is non-negative.  */
2765               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
2766                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
2767                 /* OK */;
2768               else
2769                 warning ("signed and unsigned type in conditional expression");
2770             }
2771         }
2772     }
2773   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2774     {
2775       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2776         pedwarn ("ISO C forbids conditional expr with only one void side");
2777       result_type = void_type_node;
2778     }
2779   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2780     {
2781       if (comp_target_types (type1, type2, 1))
2782         result_type = common_pointer_type (type1, type2);
2783       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2784                && TREE_CODE (orig_op1) != NOP_EXPR)
2785         result_type = qualify_type (type2, type1);
2786       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2787                && TREE_CODE (orig_op2) != NOP_EXPR)
2788         result_type = qualify_type (type1, type2);
2789       else if (VOID_TYPE_P (TREE_TYPE (type1)))
2790         {
2791           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2792             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2793           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2794                                                           TREE_TYPE (type2)));
2795         }
2796       else if (VOID_TYPE_P (TREE_TYPE (type2)))
2797         {
2798           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2799             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2800           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2801                                                           TREE_TYPE (type1)));
2802         }
2803       else
2804         {
2805           pedwarn ("pointer type mismatch in conditional expression");
2806           result_type = build_pointer_type (void_type_node);
2807         }
2808     }
2809   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2810     {
2811       if (! integer_zerop (op2))
2812         pedwarn ("pointer/integer type mismatch in conditional expression");
2813       else
2814         {
2815           op2 = null_pointer_node;
2816         }
2817       result_type = type1;
2818     }
2819   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
2820     {
2821       if (!integer_zerop (op1))
2822         pedwarn ("pointer/integer type mismatch in conditional expression");
2823       else
2824         {
2825           op1 = null_pointer_node;
2826         }
2827       result_type = type2;
2828     }
2829
2830   if (!result_type)
2831     {
2832       if (flag_cond_mismatch)
2833         result_type = void_type_node;
2834       else
2835         {
2836           error ("type mismatch in conditional expression");
2837           return error_mark_node;
2838         }
2839     }
2840
2841   /* Merge const and volatile flags of the incoming types.  */
2842   result_type
2843     = build_type_variant (result_type,
2844                           TREE_READONLY (op1) || TREE_READONLY (op2),
2845                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
2846
2847   if (result_type != TREE_TYPE (op1))
2848     op1 = convert_and_check (result_type, op1);
2849   if (result_type != TREE_TYPE (op2))
2850     op2 = convert_and_check (result_type, op2);
2851
2852   if (TREE_CODE (ifexp) == INTEGER_CST)
2853     return non_lvalue (integer_zerop (ifexp) ? op2 : op1);
2854
2855   return fold (build3 (COND_EXPR, result_type, ifexp, op1, op2));
2856 }
2857 \f
2858 /* Return a compound expression that performs two expressions and
2859    returns the value of the second of them.  */
2860
2861 tree
2862 build_compound_expr (tree expr1, tree expr2)
2863 {
2864   /* Convert arrays and functions to pointers.  */
2865   expr2 = default_function_array_conversion (expr2);
2866
2867   /* Don't let (0, 0) be null pointer constant.  */
2868   if (integer_zerop (expr2))
2869     expr2 = non_lvalue (expr2);
2870
2871   if (! TREE_SIDE_EFFECTS (expr1))
2872     {
2873       /* The left-hand operand of a comma expression is like an expression
2874          statement: with -Wextra or -Wunused, we should warn if it doesn't have
2875          any side-effects, unless it was explicitly cast to (void).  */
2876       if (warn_unused_value
2877            && ! (TREE_CODE (expr1) == CONVERT_EXPR
2878                 && VOID_TYPE_P (TREE_TYPE (expr1))))
2879         warning ("left-hand operand of comma expression has no effect");
2880     }
2881
2882   /* With -Wunused, we should also warn if the left-hand operand does have
2883      side-effects, but computes a value which is not used.  For example, in
2884      `foo() + bar(), baz()' the result of the `+' operator is not used,
2885      so we should issue a warning.  */
2886   else if (warn_unused_value)
2887     warn_if_unused_value (expr1, input_location);
2888
2889   return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
2890 }
2891
2892 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
2893
2894 tree
2895 build_c_cast (tree type, tree expr)
2896 {
2897   tree value = expr;
2898
2899   if (type == error_mark_node || expr == error_mark_node)
2900     return error_mark_node;
2901
2902   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
2903      only in <protocol> qualifications.  But when constructing cast expressions,
2904      the protocols do matter and must be kept around.  */
2905   if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
2906     return build1 (NOP_EXPR, type, expr);
2907
2908   type = TYPE_MAIN_VARIANT (type);
2909
2910   if (TREE_CODE (type) == ARRAY_TYPE)
2911     {
2912       error ("cast specifies array type");
2913       return error_mark_node;
2914     }
2915
2916   if (TREE_CODE (type) == FUNCTION_TYPE)
2917     {
2918       error ("cast specifies function type");
2919       return error_mark_node;
2920     }
2921
2922   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
2923     {
2924       if (pedantic)
2925         {
2926           if (TREE_CODE (type) == RECORD_TYPE
2927               || TREE_CODE (type) == UNION_TYPE)
2928             pedwarn ("ISO C forbids casting nonscalar to the same type");
2929         }
2930     }
2931   else if (TREE_CODE (type) == UNION_TYPE)
2932     {
2933       tree field;
2934       value = default_function_array_conversion (value);
2935
2936       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2937         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
2938                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
2939           break;
2940
2941       if (field)
2942         {
2943           tree t;
2944
2945           if (pedantic)
2946             pedwarn ("ISO C forbids casts to union type");
2947           t = digest_init (type,
2948                            build_constructor (type,
2949                                               build_tree_list (field, value)),
2950                            true, 0);
2951           TREE_CONSTANT (t) = TREE_CONSTANT (value);
2952           TREE_INVARIANT (t) = TREE_INVARIANT (value);
2953           return t;
2954         }
2955       error ("cast to union type from type not present in union");
2956       return error_mark_node;
2957     }
2958   else
2959     {
2960       tree otype, ovalue;
2961
2962       /* If casting to void, avoid the error that would come
2963          from default_conversion in the case of a non-lvalue array.  */
2964       if (type == void_type_node)
2965         return build1 (CONVERT_EXPR, type, value);
2966
2967       /* Convert functions and arrays to pointers,
2968          but don't convert any other types.  */
2969       value = default_function_array_conversion (value);
2970       otype = TREE_TYPE (value);
2971
2972       /* Optionally warn about potentially worrisome casts.  */
2973
2974       if (warn_cast_qual
2975           && TREE_CODE (type) == POINTER_TYPE
2976           && TREE_CODE (otype) == POINTER_TYPE)
2977         {
2978           tree in_type = type;
2979           tree in_otype = otype;
2980           int added = 0;
2981           int discarded = 0;
2982
2983           /* Check that the qualifiers on IN_TYPE are a superset of
2984              the qualifiers of IN_OTYPE.  The outermost level of
2985              POINTER_TYPE nodes is uninteresting and we stop as soon
2986              as we hit a non-POINTER_TYPE node on either type.  */
2987           do
2988             {
2989               in_otype = TREE_TYPE (in_otype);
2990               in_type = TREE_TYPE (in_type);
2991
2992               /* GNU C allows cv-qualified function types.  'const'
2993                  means the function is very pure, 'volatile' means it
2994                  can't return.  We need to warn when such qualifiers
2995                  are added, not when they're taken away.  */
2996               if (TREE_CODE (in_otype) == FUNCTION_TYPE
2997                   && TREE_CODE (in_type) == FUNCTION_TYPE)
2998                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
2999               else
3000                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3001             }
3002           while (TREE_CODE (in_type) == POINTER_TYPE
3003                  && TREE_CODE (in_otype) == POINTER_TYPE);
3004
3005           if (added)
3006             warning ("cast adds new qualifiers to function type");
3007
3008           if (discarded)
3009             /* There are qualifiers present in IN_OTYPE that are not
3010                present in IN_TYPE.  */
3011             warning ("cast discards qualifiers from pointer target type");
3012         }
3013
3014       /* Warn about possible alignment problems.  */
3015       if (STRICT_ALIGNMENT && warn_cast_align
3016           && TREE_CODE (type) == POINTER_TYPE
3017           && TREE_CODE (otype) == POINTER_TYPE
3018           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3019           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3020           /* Don't warn about opaque types, where the actual alignment
3021              restriction is unknown.  */
3022           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3023                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3024                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3025           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3026         warning ("cast increases required alignment of target type");
3027
3028       if (TREE_CODE (type) == INTEGER_TYPE
3029           && TREE_CODE (otype) == POINTER_TYPE
3030           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3031           && !TREE_CONSTANT (value))
3032         warning ("cast from pointer to integer of different size");
3033
3034       if (warn_bad_function_cast
3035           && TREE_CODE (value) == CALL_EXPR
3036           && TREE_CODE (type) != TREE_CODE (otype))
3037         warning ("cast does not match function type");
3038
3039       if (TREE_CODE (type) == POINTER_TYPE
3040           && TREE_CODE (otype) == INTEGER_TYPE
3041           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3042           /* Don't warn about converting any constant.  */
3043           && !TREE_CONSTANT (value))
3044         warning ("cast to pointer from integer of different size");
3045
3046       if (TREE_CODE (type) == POINTER_TYPE
3047           && TREE_CODE (otype) == POINTER_TYPE
3048           && TREE_CODE (expr) == ADDR_EXPR
3049           && DECL_P (TREE_OPERAND (expr, 0))
3050           && flag_strict_aliasing && warn_strict_aliasing
3051           && !VOID_TYPE_P (TREE_TYPE (type)))
3052         {
3053           /* Casting the address of a decl to non void pointer. Warn
3054              if the cast breaks type based aliasing.  */
3055           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3056             warning ("type-punning to incomplete type might break strict-aliasing rules");
3057           else
3058             {
3059               HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
3060               HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
3061
3062               if (!alias_sets_conflict_p (set1, set2))
3063                 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3064               else if (warn_strict_aliasing > 1
3065                        && !alias_sets_might_conflict_p (set1, set2))
3066                 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3067             }
3068         }
3069
3070       /* If pedantic, warn for conversions between function and object
3071          pointer types, except for converting a null pointer constant
3072          to function pointer type.  */
3073       if (pedantic
3074           && TREE_CODE (type) == POINTER_TYPE
3075           && TREE_CODE (otype) == POINTER_TYPE
3076           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3077           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3078         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3079
3080       if (pedantic
3081           && TREE_CODE (type) == POINTER_TYPE
3082           && TREE_CODE (otype) == POINTER_TYPE
3083           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3084           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3085           && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3086                && TREE_CODE (expr) != NOP_EXPR))
3087         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3088
3089       ovalue = value;
3090       /* Replace a nonvolatile const static variable with its value.  */
3091       if (optimize && TREE_CODE (value) == VAR_DECL)
3092         value = decl_constant_value (value);
3093       value = convert (type, value);
3094
3095       /* Ignore any integer overflow caused by the cast.  */
3096       if (TREE_CODE (value) == INTEGER_CST)
3097         {
3098           if (EXPR_P (ovalue))
3099             /* If OVALUE had overflow set, then so will VALUE, so it
3100                is safe to overwrite.  */
3101             TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3102           else
3103             TREE_OVERFLOW (value) = 0;
3104
3105           if (TREE_CODE_CLASS (TREE_CODE (ovalue)) == 'c')
3106             /* Similarly, constant_overflow cannot have become
3107                cleared.  */
3108             TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3109         }
3110     }
3111
3112   /* Don't let (void *) (FOO *) 0 be a null pointer constant.  */
3113   if (TREE_CODE (value) == INTEGER_CST
3114       && TREE_CODE (expr) == INTEGER_CST
3115       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3116     value = non_lvalue (value);
3117
3118   /* Don't let a cast be an lvalue.  */
3119   if (value == expr)
3120     value = non_lvalue (value);
3121
3122   return value;
3123 }
3124
3125 /* Interpret a cast of expression EXPR to type TYPE.  */
3126 tree
3127 c_cast_expr (tree type, tree expr)
3128 {
3129   int saved_wsp = warn_strict_prototypes;
3130
3131   /* This avoids warnings about unprototyped casts on
3132      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3133   if (TREE_CODE (expr) == INTEGER_CST)
3134     warn_strict_prototypes = 0;
3135   type = groktypename (type);
3136   warn_strict_prototypes = saved_wsp;
3137
3138   return build_c_cast (type, expr);
3139 }
3140
3141 \f
3142 /* Build an assignment expression of lvalue LHS from value RHS.
3143    MODIFYCODE is the code for a binary operator that we use
3144    to combine the old value of LHS with RHS to get the new value.
3145    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3146
3147 tree
3148 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3149 {
3150   tree result;
3151   tree newrhs;
3152   tree lhstype = TREE_TYPE (lhs);
3153   tree olhstype = lhstype;
3154
3155   /* Types that aren't fully specified cannot be used in assignments.  */
3156   lhs = require_complete_type (lhs);
3157
3158   /* Avoid duplicate error messages from operands that had errors.  */
3159   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3160     return error_mark_node;
3161
3162   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3163   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3164      whose value is 0 to count as a null pointer constant.  */
3165   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3166     rhs = TREE_OPERAND (rhs, 0);
3167
3168   newrhs = rhs;
3169
3170   /* If a binary op has been requested, combine the old LHS value with the RHS
3171      producing the value we should actually store into the LHS.  */
3172
3173   if (modifycode != NOP_EXPR)
3174     {
3175       lhs = stabilize_reference (lhs);
3176       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3177     }
3178
3179   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3180     return error_mark_node;
3181
3182   /* Warn about storing in something that is `const'.  */
3183
3184   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3185       || ((TREE_CODE (lhstype) == RECORD_TYPE
3186            || TREE_CODE (lhstype) == UNION_TYPE)
3187           && C_TYPE_FIELDS_READONLY (lhstype)))
3188     readonly_error (lhs, "assignment");
3189
3190   /* If storing into a structure or union member,
3191      it has probably been given type `int'.
3192      Compute the type that would go with
3193      the actual amount of storage the member occupies.  */
3194
3195   if (TREE_CODE (lhs) == COMPONENT_REF
3196       && (TREE_CODE (lhstype) == INTEGER_TYPE
3197           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3198           || TREE_CODE (lhstype) == REAL_TYPE
3199           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3200     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3201
3202   /* If storing in a field that is in actuality a short or narrower than one,
3203      we must store in the field in its actual type.  */
3204
3205   if (lhstype != TREE_TYPE (lhs))
3206     {
3207       lhs = copy_node (lhs);
3208       TREE_TYPE (lhs) = lhstype;
3209     }
3210
3211   /* Convert new value to destination type.  */
3212
3213   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3214                                    NULL_TREE, NULL_TREE, 0);
3215   if (TREE_CODE (newrhs) == ERROR_MARK)
3216     return error_mark_node;
3217
3218   /* Scan operands */
3219
3220   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
3221   TREE_SIDE_EFFECTS (result) = 1;
3222
3223   /* If we got the LHS in a different type for storing in,
3224      convert the result back to the nominal type of LHS
3225      so that the value we return always has the same type
3226      as the LHS argument.  */
3227
3228   if (olhstype == TREE_TYPE (result))
3229     return result;
3230   return convert_for_assignment (olhstype, result, _("assignment"),
3231                                  NULL_TREE, NULL_TREE, 0);
3232 }
3233 \f
3234 /* Convert value RHS to type TYPE as preparation for an assignment
3235    to an lvalue of type TYPE.
3236    The real work of conversion is done by `convert'.
3237    The purpose of this function is to generate error messages
3238    for assignments that are not allowed in C.
3239    ERRTYPE is a string to use in error messages:
3240    "assignment", "return", etc.  If it is null, this is parameter passing
3241    for a function call (and different error messages are output).
3242
3243    FUNNAME is the name of the function being called,
3244    as an IDENTIFIER_NODE, or null.
3245    PARMNUM is the number of the argument, for printing in error messages.  */
3246
3247 static tree
3248 convert_for_assignment (tree type, tree rhs, const char *errtype,
3249                         tree fundecl, tree funname, int parmnum)
3250 {
3251   enum tree_code codel = TREE_CODE (type);
3252   tree rhstype;
3253   enum tree_code coder;
3254
3255   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3256   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3257      whose value is 0 to count as a null pointer constant.  */
3258   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3259     rhs = TREE_OPERAND (rhs, 0);
3260
3261   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3262       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3263     rhs = default_conversion (rhs);
3264   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3265     rhs = decl_constant_value_for_broken_optimization (rhs);
3266
3267   rhstype = TREE_TYPE (rhs);
3268   coder = TREE_CODE (rhstype);
3269
3270   if (coder == ERROR_MARK)
3271     return error_mark_node;
3272
3273   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3274     {
3275       overflow_warning (rhs);
3276       /* Check for Objective-C protocols.  This will automatically
3277          issue a warning if there are protocol violations.  No need to
3278          use the return value.  */
3279       if (c_dialect_objc ())
3280         objc_comptypes (type, rhstype, 0);
3281       return rhs;
3282     }
3283
3284   if (coder == VOID_TYPE)
3285     {
3286       error ("void value not ignored as it ought to be");
3287       return error_mark_node;
3288     }
3289   /* A type converts to a reference to it.
3290      This code doesn't fully support references, it's just for the
3291      special case of va_start and va_copy.  */
3292   if (codel == REFERENCE_TYPE
3293       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3294     {
3295       if (!lvalue_p (rhs))
3296         {
3297           error ("cannot pass rvalue to reference parameter");
3298           return error_mark_node;
3299         }
3300       if (!c_mark_addressable (rhs))
3301         return error_mark_node;
3302       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3303
3304       /* We already know that these two types are compatible, but they
3305          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3306          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3307          likely to be va_list, a typedef to __builtin_va_list, which
3308          is different enough that it will cause problems later.  */
3309       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3310         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3311
3312       rhs = build1 (NOP_EXPR, type, rhs);
3313       return rhs;
3314     }
3315   /* Some types can interconvert without explicit casts.  */
3316   else if (codel == VECTOR_TYPE
3317            && vector_types_convertible_p (type, TREE_TYPE (rhs)))
3318     return convert (type, rhs);
3319   /* Arithmetic types all interconvert, and enum is treated like int.  */
3320   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3321             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3322             || codel == BOOLEAN_TYPE)
3323            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3324                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3325                || coder == BOOLEAN_TYPE))
3326     return convert_and_check (type, rhs);
3327
3328   /* Conversion to a transparent union from its member types.
3329      This applies only to function arguments.  */
3330   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
3331     {
3332       tree memb_types;
3333       tree marginal_memb_type = 0;
3334
3335       for (memb_types = TYPE_FIELDS (type); memb_types;
3336            memb_types = TREE_CHAIN (memb_types))
3337         {
3338           tree memb_type = TREE_TYPE (memb_types);
3339
3340           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3341                          TYPE_MAIN_VARIANT (rhstype)))
3342             break;
3343
3344           if (TREE_CODE (memb_type) != POINTER_TYPE)
3345             continue;
3346
3347           if (coder == POINTER_TYPE)
3348             {
3349               tree ttl = TREE_TYPE (memb_type);
3350               tree ttr = TREE_TYPE (rhstype);
3351
3352               /* Any non-function converts to a [const][volatile] void *
3353                  and vice versa; otherwise, targets must be the same.
3354                  Meanwhile, the lhs target must have all the qualifiers of
3355                  the rhs.  */
3356               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3357                   || comp_target_types (memb_type, rhstype, 0))
3358                 {
3359                   /* If this type won't generate any warnings, use it.  */
3360                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3361                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3362                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3363                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3364                              == TYPE_QUALS (ttr))
3365                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3366                              == TYPE_QUALS (ttl))))
3367                     break;
3368
3369                   /* Keep looking for a better type, but remember this one.  */
3370                   if (! marginal_memb_type)
3371                     marginal_memb_type = memb_type;
3372                 }
3373             }
3374
3375           /* Can convert integer zero to any pointer type.  */
3376           if (integer_zerop (rhs)
3377               || (TREE_CODE (rhs) == NOP_EXPR
3378                   && integer_zerop (TREE_OPERAND (rhs, 0))))
3379             {
3380               rhs = null_pointer_node;
3381               break;
3382             }
3383         }
3384
3385       if (memb_types || marginal_memb_type)
3386         {
3387           if (! memb_types)
3388             {
3389               /* We have only a marginally acceptable member type;
3390                  it needs a warning.  */
3391               tree ttl = TREE_TYPE (marginal_memb_type);
3392               tree ttr = TREE_TYPE (rhstype);
3393
3394               /* Const and volatile mean something different for function
3395                  types, so the usual warnings are not appropriate.  */
3396               if (TREE_CODE (ttr) == FUNCTION_TYPE
3397                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3398                 {
3399                   /* Because const and volatile on functions are
3400                      restrictions that say the function will not do
3401                      certain things, it is okay to use a const or volatile
3402                      function where an ordinary one is wanted, but not
3403                      vice-versa.  */
3404                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3405                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
3406                                          errtype, funname, parmnum);
3407                 }
3408               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3409                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3410                                      errtype, funname,
3411                                      parmnum);
3412             }
3413
3414           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
3415             pedwarn ("ISO C prohibits argument conversion to union type");
3416
3417           return build1 (NOP_EXPR, type, rhs);
3418         }
3419     }
3420
3421   /* Conversions among pointers */
3422   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3423            && (coder == codel))
3424     {
3425       tree ttl = TREE_TYPE (type);
3426       tree ttr = TREE_TYPE (rhstype);
3427       bool is_opaque_pointer;
3428       int target_cmp = 0;   /* Cache comp_target_types () result.  */
3429
3430       /* Opaque pointers are treated like void pointers.  */
3431       is_opaque_pointer = (targetm.vector_opaque_p (type)
3432                            || targetm.vector_opaque_p (rhstype))
3433         && TREE_CODE (ttl) == VECTOR_TYPE
3434         && TREE_CODE (ttr) == VECTOR_TYPE;
3435
3436       /* Any non-function converts to a [const][volatile] void *
3437          and vice versa; otherwise, targets must be the same.
3438          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3439       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3440           || (target_cmp = comp_target_types (type, rhstype, 0))
3441           || is_opaque_pointer
3442           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3443               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3444         {
3445           if (pedantic
3446               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3447                   ||
3448                   (VOID_TYPE_P (ttr)
3449                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3450                       which are not ANSI null ptr constants.  */
3451                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3452                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3453             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
3454                                  errtype, funname, parmnum);
3455           /* Const and volatile mean something different for function types,
3456              so the usual warnings are not appropriate.  */
3457           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3458                    && TREE_CODE (ttl) != FUNCTION_TYPE)
3459             {
3460               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3461                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3462                                      errtype, funname, parmnum);
3463               /* If this is not a case of ignoring a mismatch in signedness,
3464                  no warning.  */
3465               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3466                        || target_cmp)
3467                 ;
3468               /* If there is a mismatch, do warn.  */
3469               else
3470                 warn_for_assignment ("pointer targets in %s differ in signedness",
3471                                      errtype, funname, parmnum);
3472             }
3473           else if (TREE_CODE (ttl) == FUNCTION_TYPE
3474                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3475             {
3476               /* Because const and volatile on functions are restrictions
3477                  that say the function will not do certain things,
3478                  it is okay to use a const or volatile function
3479                  where an ordinary one is wanted, but not vice-versa.  */
3480               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3481                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
3482                                      errtype, funname, parmnum);
3483             }
3484         }
3485       else
3486         warn_for_assignment ("%s from incompatible pointer type",
3487                              errtype, funname, parmnum);
3488       return convert (type, rhs);
3489     }
3490   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3491     {
3492       error ("invalid use of non-lvalue array");
3493       return error_mark_node;
3494     }
3495   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3496     {
3497       /* An explicit constant 0 can convert to a pointer,
3498          or one that results from arithmetic, even including
3499          a cast to integer type.  */
3500       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3501           &&
3502           ! (TREE_CODE (rhs) == NOP_EXPR
3503              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3504              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3505              && integer_zerop (TREE_OPERAND (rhs, 0))))
3506           warn_for_assignment ("%s makes pointer from integer without a cast",
3507                                errtype, funname, parmnum);
3508
3509       return convert (type, rhs);
3510     }
3511   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3512     {
3513       warn_for_assignment ("%s makes integer from pointer without a cast",
3514                            errtype, funname, parmnum);
3515       return convert (type, rhs);
3516     }
3517   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3518     return convert (type, rhs);
3519
3520   if (!errtype)
3521     {
3522       if (funname)
3523         {
3524           tree selector = objc_message_selector ();
3525
3526           if (selector && parmnum > 2)
3527             error ("incompatible type for argument %d of `%s'",
3528                    parmnum - 2, IDENTIFIER_POINTER (selector));
3529           else
3530             error ("incompatible type for argument %d of `%s'",
3531                    parmnum, IDENTIFIER_POINTER (funname));
3532         }
3533       else
3534         error ("incompatible type for argument %d of indirect function call",
3535                parmnum);
3536     }
3537   else
3538     error ("incompatible types in %s", errtype);
3539
3540   return error_mark_node;
3541 }
3542
3543 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
3544    is used for error and waring reporting and indicates which argument
3545    is being processed.  */
3546
3547 tree
3548 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3549 {
3550   tree ret, type;
3551
3552   /* If FN was prototyped, the value has been converted already
3553      in convert_arguments.  */
3554   if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3555     return value;
3556
3557   type = TREE_TYPE (parm);
3558   ret = convert_for_assignment (type, value,
3559                                 (char *) 0 /* arg passing  */, fn,
3560                                 DECL_NAME (fn), argnum);
3561   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3562       && INTEGRAL_TYPE_P (type)
3563       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3564     ret = default_conversion (ret);
3565   return ret;
3566 }
3567
3568 /* Print a warning using MSGID.
3569    It gets OPNAME as its one parameter.
3570    if OPNAME is null and ARGNUM is 0, it is replaced by "passing arg of `FUNCTION'".
3571    Otherwise if OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
3572    FUNCTION and ARGNUM are handled specially if we are building an
3573    Objective-C selector.  */
3574
3575 static void
3576 warn_for_assignment (const char *msgid, const char *opname, tree function,
3577                      int argnum)
3578 {
3579   if (opname == 0)
3580     {
3581       tree selector = objc_message_selector ();
3582       char * new_opname;
3583
3584       if (selector && argnum > 2)
3585         {
3586           function = selector;
3587           argnum -= 2;
3588         }
3589       if (argnum == 0)
3590         {
3591           if (function)
3592             {
3593               /* Function name is known; supply it.  */
3594               const char *const argstring = _("passing arg of `%s'");
3595               new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
3596                                    + strlen (argstring) + 1 + 1);
3597               sprintf (new_opname, argstring,
3598                        IDENTIFIER_POINTER (function));
3599             }
3600           else
3601             {
3602               /* Function name unknown (call through ptr).  */
3603               const char *const argnofun = _("passing arg of pointer to function");
3604               new_opname = (char *) alloca (strlen (argnofun) + 1 + 1);
3605               sprintf (new_opname, argnofun);
3606             }
3607         }
3608       else if (function)
3609         {
3610           /* Function name is known; supply it.  */
3611           const char *const argstring = _("passing arg %d of `%s'");
3612           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
3613                                + strlen (argstring) + 1 + 25 /*%d*/ + 1);
3614           sprintf (new_opname, argstring, argnum,
3615                    IDENTIFIER_POINTER (function));
3616         }
3617       else
3618         {
3619           /* Function name unknown (call through ptr); just give arg number.  */
3620           const char *const argnofun = _("passing arg %d of pointer to function");
3621           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
3622           sprintf (new_opname, argnofun, argnum);
3623         }
3624       opname = new_opname;
3625     }
3626   pedwarn (msgid, opname);
3627 }
3628 \f
3629 /* If VALUE is a compound expr all of whose expressions are constant, then
3630    return its value.  Otherwise, return error_mark_node.
3631
3632    This is for handling COMPOUND_EXPRs as initializer elements
3633    which is allowed with a warning when -pedantic is specified.  */
3634
3635 static tree
3636 valid_compound_expr_initializer (tree value, tree endtype)
3637 {
3638   if (TREE_CODE (value) == COMPOUND_EXPR)
3639     {
3640       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3641           == error_mark_node)
3642         return error_mark_node;
3643       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3644                                               endtype);
3645     }
3646   else if (! TREE_CONSTANT (value)
3647            && ! initializer_constant_valid_p (value, endtype))
3648     return error_mark_node;
3649   else
3650     return value;
3651 }
3652 \f
3653 /* Perform appropriate conversions on the initial value of a variable,
3654    store it in the declaration DECL,
3655    and print any error messages that are appropriate.
3656    If the init is invalid, store an ERROR_MARK.  */
3657
3658 void
3659 store_init_value (tree decl, tree init)
3660 {
3661   tree value, type;
3662
3663   /* If variable's type was invalidly declared, just ignore it.  */
3664
3665   type = TREE_TYPE (decl);
3666   if (TREE_CODE (type) == ERROR_MARK)
3667     return;
3668
3669   /* Digest the specified initializer into an expression.  */
3670
3671   value = digest_init (type, init, true, TREE_STATIC (decl));
3672
3673   /* Store the expression if valid; else report error.  */
3674
3675   if (warn_traditional && !in_system_header
3676       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
3677     warning ("traditional C rejects automatic aggregate initialization");
3678
3679   DECL_INITIAL (decl) = value;
3680
3681   /* ANSI wants warnings about out-of-range constant initializers.  */
3682   STRIP_TYPE_NOPS (value);
3683   constant_expression_warning (value);
3684
3685   /* Check if we need to set array size from compound literal size.  */
3686   if (TREE_CODE (type) == ARRAY_TYPE
3687       && TYPE_DOMAIN (type) == 0
3688       && value != error_mark_node)
3689     {
3690       tree inside_init = init;
3691
3692       if (TREE_CODE (init) == NON_LVALUE_EXPR)
3693         inside_init = TREE_OPERAND (init, 0);
3694       inside_init = fold (inside_init);
3695
3696       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3697         {
3698           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3699
3700           if (TYPE_DOMAIN (TREE_TYPE (decl)))
3701             {
3702               /* For int foo[] = (int [3]){1}; we need to set array size
3703                  now since later on array initializer will be just the
3704                  brace enclosed list of the compound literal.  */
3705               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3706               layout_type (type);
3707               layout_decl (decl, 0);
3708             }
3709         }
3710     }
3711 }
3712 \f
3713 /* Methods for storing and printing names for error messages.  */
3714
3715 /* Implement a spelling stack that allows components of a name to be pushed
3716    and popped.  Each element on the stack is this structure.  */
3717
3718 struct spelling
3719 {
3720   int kind;
3721   union
3722     {
3723       int i;
3724       const char *s;
3725     } u;
3726 };
3727
3728 #define SPELLING_STRING 1
3729 #define SPELLING_MEMBER 2
3730 #define SPELLING_BOUNDS 3
3731
3732 static struct spelling *spelling;       /* Next stack element (unused).  */
3733 static struct spelling *spelling_base;  /* Spelling stack base.  */
3734 static int spelling_size;               /* Size of the spelling stack.  */
3735
3736 /* Macros to save and restore the spelling stack around push_... functions.
3737    Alternative to SAVE_SPELLING_STACK.  */
3738
3739 #define SPELLING_DEPTH() (spelling - spelling_base)
3740 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3741
3742 /* Push an element on the spelling stack with type KIND and assign VALUE
3743    to MEMBER.  */
3744
3745 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
3746 {                                                                       \
3747   int depth = SPELLING_DEPTH ();                                        \
3748                                                                         \
3749   if (depth >= spelling_size)                                           \
3750     {                                                                   \
3751       spelling_size += 10;                                              \
3752       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
3753                                   spelling_size);                       \
3754       RESTORE_SPELLING_DEPTH (depth);                                   \
3755     }                                                                   \
3756                                                                         \
3757   spelling->kind = (KIND);                                              \
3758   spelling->MEMBER = (VALUE);                                           \
3759   spelling++;                                                           \
3760 }
3761
3762 /* Push STRING on the stack.  Printed literally.  */
3763
3764 static void
3765 push_string (const char *string)
3766 {
3767   PUSH_SPELLING (SPELLING_STRING, string, u.s);
3768 }
3769
3770 /* Push a member name on the stack.  Printed as '.' STRING.  */
3771
3772 static void
3773 push_member_name (tree decl)
3774 {
3775   const char *const string
3776     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3777   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3778 }
3779
3780 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
3781
3782 static void
3783 push_array_bounds (int bounds)
3784 {
3785   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
3786 }
3787
3788 /* Compute the maximum size in bytes of the printed spelling.  */
3789
3790 static int
3791 spelling_length (void)
3792 {
3793   int size = 0;
3794   struct spelling *p;
3795
3796   for (p = spelling_base; p < spelling; p++)
3797     {
3798       if (p->kind == SPELLING_BOUNDS)
3799         size += 25;
3800       else
3801         size += strlen (p->u.s) + 1;
3802     }
3803
3804   return size;
3805 }
3806
3807 /* Print the spelling to BUFFER and return it.  */
3808
3809 static char *
3810 print_spelling (char *buffer)
3811 {
3812   char *d = buffer;
3813   struct spelling *p;
3814
3815   for (p = spelling_base; p < spelling; p++)
3816     if (p->kind == SPELLING_BOUNDS)
3817       {
3818         sprintf (d, "[%d]", p->u.i);
3819         d += strlen (d);
3820       }
3821     else
3822       {
3823         const char *s;
3824         if (p->kind == SPELLING_MEMBER)
3825           *d++ = '.';
3826         for (s = p->u.s; (*d = *s++); d++)
3827           ;
3828       }
3829   *d++ = '\0';
3830   return buffer;
3831 }
3832
3833 /* Issue an error message for a bad initializer component.
3834    MSGID identifies the message.
3835    The component name is taken from the spelling stack.  */
3836
3837 void
3838 error_init (const char *msgid)
3839 {
3840   char *ofwhat;
3841
3842   error ("%s", _(msgid));
3843   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3844   if (*ofwhat)
3845     error ("(near initialization for `%s')", ofwhat);
3846 }
3847
3848 /* Issue a pedantic warning for a bad initializer component.
3849    MSGID identifies the message.
3850    The component name is taken from the spelling stack.  */
3851
3852 void
3853 pedwarn_init (const char *msgid)
3854 {
3855   char *ofwhat;
3856
3857   pedwarn ("%s", _(msgid));
3858   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3859   if (*ofwhat)
3860     pedwarn ("(near initialization for `%s')", ofwhat);
3861 }
3862
3863 /* Issue a warning for a bad initializer component.
3864    MSGID identifies the message.
3865    The component name is taken from the spelling stack.  */
3866
3867 static void
3868 warning_init (const char *msgid)
3869 {
3870   char *ofwhat;
3871
3872   warning ("%s", _(msgid));
3873   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3874   if (*ofwhat)
3875     warning ("(near initialization for `%s')", ofwhat);
3876 }
3877 \f
3878 /* If TYPE is an array type and EXPR is a parenthesized string
3879    constant, warn if pedantic that EXPR is being used to initialize an
3880    object of type TYPE.  */
3881
3882 void
3883 maybe_warn_string_init (tree type, struct c_expr expr)
3884 {
3885   if (pedantic
3886       && TREE_CODE (type) == ARRAY_TYPE
3887       && TREE_CODE (expr.value) == STRING_CST
3888       && expr.original_code != STRING_CST)
3889     pedwarn_init ("array initialized from parenthesized string constant");
3890 }
3891
3892 /* Digest the parser output INIT as an initializer for type TYPE.
3893    Return a C expression of type TYPE to represent the initial value.
3894
3895    If INIT is a string constant, STRICT_STRING is true if it is
3896    unparenthesized or we should not warn here for it being parenthesized.
3897    For other types of INIT, STRICT_STRING is not used.
3898
3899    REQUIRE_CONSTANT requests an error if non-constant initializers or
3900    elements are seen.  */
3901
3902 static tree
3903 digest_init (tree type, tree init, bool strict_string, int require_constant)
3904 {
3905   enum tree_code code = TREE_CODE (type);
3906   tree inside_init = init;
3907
3908   if (type == error_mark_node
3909       || init == error_mark_node
3910       || TREE_TYPE (init) == error_mark_node)
3911     return error_mark_node;
3912
3913   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3914   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3915      whose value is 0 to count as a null pointer constant.  */
3916   if (TREE_CODE (init) == NON_LVALUE_EXPR)
3917     inside_init = TREE_OPERAND (init, 0);
3918
3919   inside_init = fold (inside_init);
3920
3921   /* Initialization of an array of chars from a string constant
3922      optionally enclosed in braces.  */
3923
3924   if (code == ARRAY_TYPE && inside_init
3925       && TREE_CODE (inside_init) == STRING_CST)
3926     {
3927       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3928       /* Note that an array could be both an array of character type
3929          and an array of wchar_t if wchar_t is signed char or unsigned
3930          char.  */
3931       bool char_array = (typ1 == char_type_node
3932                          || typ1 == signed_char_type_node
3933                          || typ1 == unsigned_char_type_node);
3934       bool wchar_array = !!comptypes (typ1, wchar_type_node);
3935       if (char_array || wchar_array)
3936         {
3937           struct c_expr expr;
3938           bool char_string;
3939           expr.value = inside_init;
3940           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
3941           maybe_warn_string_init (type, expr);
3942
3943           char_string
3944             = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
3945                == char_type_node);
3946
3947           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3948                          TYPE_MAIN_VARIANT (type)))
3949             return inside_init;
3950
3951           if (!wchar_array && !char_string)
3952             {
3953               error_init ("char-array initialized from wide string");
3954               return error_mark_node;
3955             }
3956           if (char_string && !char_array)
3957             {
3958               error_init ("wchar_t-array initialized from non-wide string");
3959               return error_mark_node;
3960             }
3961
3962           TREE_TYPE (inside_init) = type;
3963           if (TYPE_DOMAIN (type) != 0
3964               && TYPE_SIZE (type) != 0
3965               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
3966               /* Subtract 1 (or sizeof (wchar_t))
3967                  because it's ok to ignore the terminating null char
3968                  that is counted in the length of the constant.  */
3969               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
3970                                        TREE_STRING_LENGTH (inside_init)
3971                                        - ((TYPE_PRECISION (typ1)
3972                                            != TYPE_PRECISION (char_type_node))
3973                                           ? (TYPE_PRECISION (wchar_type_node)
3974                                              / BITS_PER_UNIT)
3975                                           : 1)))
3976             pedwarn_init ("initializer-string for array of chars is too long");
3977
3978           return inside_init;
3979         }
3980       else if (INTEGRAL_TYPE_P (typ1))
3981         {
3982           error_init ("array of inappropriate type initialized "
3983                       "from string constant");
3984           return error_mark_node;
3985         }
3986     }
3987
3988   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
3989      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
3990      below and handle as a constructor.  */
3991     if (code == VECTOR_TYPE
3992         && vector_types_convertible_p (TREE_TYPE (inside_init), type)
3993         && TREE_CONSTANT (inside_init))
3994       {
3995         if (TREE_CODE (inside_init) == VECTOR_CST
3996             && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3997                           TYPE_MAIN_VARIANT (type)))
3998           return inside_init;
3999         else
4000           return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
4001       }
4002
4003   /* Any type can be initialized
4004      from an expression of the same type, optionally with braces.  */
4005
4006   if (inside_init && TREE_TYPE (inside_init) != 0
4007       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4008                      TYPE_MAIN_VARIANT (type))
4009           || (code == ARRAY_TYPE
4010               && comptypes (TREE_TYPE (inside_init), type))
4011           || (code == VECTOR_TYPE
4012               && comptypes (TREE_TYPE (inside_init), type))
4013           || (code == POINTER_TYPE
4014               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4015               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4016                             TREE_TYPE (type)))
4017           || (code == POINTER_TYPE
4018               && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
4019               && comptypes (TREE_TYPE (inside_init),
4020                             TREE_TYPE (type)))))
4021     {
4022       if (code == POINTER_TYPE)
4023         {
4024           inside_init = default_function_array_conversion (inside_init);
4025
4026           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4027             {
4028               error_init ("invalid use of non-lvalue array");
4029               return error_mark_node;
4030             }
4031          }
4032
4033       if (code == VECTOR_TYPE)
4034         /* Although the types are compatible, we may require a
4035            conversion.  */
4036         inside_init = convert (type, inside_init);
4037
4038       if (require_constant && !flag_isoc99
4039           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4040         {
4041           /* As an extension, allow initializing objects with static storage
4042              duration with compound literals (which are then treated just as
4043              the brace enclosed list they contain).  */
4044           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4045           inside_init = DECL_INITIAL (decl);
4046         }
4047
4048       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4049           && TREE_CODE (inside_init) != CONSTRUCTOR)
4050         {
4051           error_init ("array initialized from non-constant array expression");
4052           return error_mark_node;
4053         }
4054
4055       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4056         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4057
4058       /* Compound expressions can only occur here if -pedantic or
4059          -pedantic-errors is specified.  In the later case, we always want
4060          an error.  In the former case, we simply want a warning.  */
4061       if (require_constant && pedantic
4062           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4063         {
4064           inside_init
4065             = valid_compound_expr_initializer (inside_init,
4066                                                TREE_TYPE (inside_init));
4067           if (inside_init == error_mark_node)
4068             error_init ("initializer element is not constant");
4069           else
4070             pedwarn_init ("initializer element is not constant");
4071           if (flag_pedantic_errors)
4072             inside_init = error_mark_node;
4073         }
4074       else if (require_constant
4075                && (!TREE_CONSTANT (inside_init)
4076                    /* This test catches things like `7 / 0' which
4077                       result in an expression for which TREE_CONSTANT
4078                       is true, but which is not actually something
4079                       that is a legal constant.  We really should not
4080                       be using this function, because it is a part of
4081                       the back-end.  Instead, the expression should
4082                       already have been turned into ERROR_MARK_NODE.  */
4083                    || !initializer_constant_valid_p (inside_init,
4084                                                      TREE_TYPE (inside_init))))
4085         {
4086           error_init ("initializer element is not constant");
4087           inside_init = error_mark_node;
4088         }
4089
4090       return inside_init;
4091     }
4092
4093   /* Handle scalar types, including conversions.  */
4094
4095   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4096       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
4097       || code == VECTOR_TYPE)
4098     {
4099       /* Note that convert_for_assignment calls default_conversion
4100          for arrays and functions.  We must not call it in the
4101          case where inside_init is a null pointer constant.  */
4102       inside_init
4103         = convert_for_assignment (type, init, _("initialization"),
4104                                   NULL_TREE, NULL_TREE, 0);
4105
4106       if (require_constant && ! TREE_CONSTANT (inside_init))
4107         {
4108           error_init ("initializer element is not constant");
4109           inside_init = error_mark_node;
4110         }
4111       else if (require_constant
4112                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4113         {
4114           error_init ("initializer element is not computable at load time");
4115           inside_init = error_mark_node;
4116         }
4117
4118       return inside_init;
4119     }
4120
4121   /* Come here only for records and arrays.  */
4122
4123   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4124     {
4125       error_init ("variable-sized object may not be initialized");
4126       return error_mark_node;
4127     }
4128
4129   error_init ("invalid initializer");
4130   return error_mark_node;
4131 }
4132 \f
4133 /* Handle initializers that use braces.  */
4134
4135 /* Type of object we are accumulating a constructor for.
4136    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4137 static tree constructor_type;
4138
4139 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4140    left to fill.  */
4141 static tree constructor_fields;
4142
4143 /* For an ARRAY_TYPE, this is the specified index
4144    at which to store the next element we get.  */
4145 static tree constructor_index;
4146
4147 /* For an ARRAY_TYPE, this is the maximum index.  */
4148 static tree constructor_max_index;
4149
4150 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4151 static tree constructor_unfilled_fields;
4152
4153 /* For an ARRAY_TYPE, this is the index of the first element
4154    not yet written out.  */
4155 static tree constructor_unfilled_index;
4156
4157 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4158    This is so we can generate gaps between fields, when appropriate.  */
4159 static tree constructor_bit_index;
4160
4161 /* If we are saving up the elements rather than allocating them,
4162    this is the list of elements so far (in reverse order,
4163    most recent first).  */
4164 static tree constructor_elements;
4165
4166 /* 1 if constructor should be incrementally stored into a constructor chain,
4167    0 if all the elements should be kept in AVL tree.  */
4168 static int constructor_incremental;
4169
4170 /* 1 if so far this constructor's elements are all compile-time constants.  */
4171 static int constructor_constant;
4172
4173 /* 1 if so far this constructor's elements are all valid address constants.  */
4174 static int constructor_simple;
4175
4176 /* 1 if this constructor is erroneous so far.  */
4177 static int constructor_erroneous;
4178
4179 /* Structure for managing pending initializer elements, organized as an
4180    AVL tree.  */
4181
4182 struct init_node
4183 {
4184   struct init_node *left, *right;
4185   struct init_node *parent;
4186   int balance;
4187   tree purpose;
4188   tree value;
4189 };
4190
4191 /* Tree of pending elements at this constructor level.
4192    These are elements encountered out of order
4193    which belong at places we haven't reached yet in actually
4194    writing the output.
4195    Will never hold tree nodes across GC runs.  */
4196 static struct init_node *constructor_pending_elts;
4197
4198 /* The SPELLING_DEPTH of this constructor.  */
4199 static int constructor_depth;
4200
4201 /* 0 if implicitly pushing constructor levels is allowed.  */
4202 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4203
4204 /* DECL node for which an initializer is being read.
4205    0 means we are reading a constructor expression
4206    such as (struct foo) {...}.  */
4207 static tree constructor_decl;
4208
4209 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4210 static const char *constructor_asmspec;
4211
4212 /* Nonzero if this is an initializer for a top-level decl.  */
4213 static int constructor_top_level;
4214
4215 /* Nonzero if there were any member designators in this initializer.  */
4216 static int constructor_designated;
4217
4218 /* Nesting depth of designator list.  */
4219 static int designator_depth;
4220
4221 /* Nonzero if there were diagnosed errors in this designator list.  */
4222 static int designator_errorneous;
4223
4224 \f
4225 /* This stack has a level for each implicit or explicit level of
4226    structuring in the initializer, including the outermost one.  It
4227    saves the values of most of the variables above.  */
4228
4229 struct constructor_range_stack;
4230
4231 struct constructor_stack
4232 {
4233   struct constructor_stack *next;
4234   tree type;
4235   tree fields;
4236   tree index;
4237   tree max_index;
4238   tree unfilled_index;
4239   tree unfilled_fields;
4240   tree bit_index;
4241   tree elements;
4242   struct init_node *pending_elts;
4243   int offset;
4244   int depth;
4245   /* If value nonzero, this value should replace the entire
4246      constructor at this level.  */
4247   struct c_expr replacement_value;
4248   struct constructor_range_stack *range_stack;
4249   char constant;
4250   char simple;
4251   char implicit;
4252   char erroneous;
4253   char outer;
4254   char incremental;
4255   char designated;
4256 };
4257
4258 struct constructor_stack *constructor_stack;
4259
4260 /* This stack represents designators from some range designator up to
4261    the last designator in the list.  */
4262
4263 struct constructor_range_stack
4264 {
4265   struct constructor_range_stack *next, *prev;
4266   struct constructor_stack *stack;
4267   tree range_start;
4268   tree index;
4269   tree range_end;
4270   tree fields;
4271 };
4272
4273 struct constructor_range_stack *constructor_range_stack;
4274
4275 /* This stack records separate initializers that are nested.
4276    Nested initializers can't happen in ANSI C, but GNU C allows them
4277    in cases like { ... (struct foo) { ... } ... }.  */
4278
4279 struct initializer_stack
4280 {
4281   struct initializer_stack *next;
4282   tree decl;
4283   const char *asmspec;
4284   struct constructor_stack *constructor_stack;
4285   struct constructor_range_stack *constructor_range_stack;
4286   tree elements;
4287   struct spelling *spelling;
4288   struct spelling *spelling_base;
4289   int spelling_size;
4290   char top_level;
4291   char require_constant_value;
4292   char require_constant_elements;
4293 };
4294
4295 struct initializer_stack *initializer_stack;
4296 \f
4297 /* Prepare to parse and output the initializer for variable DECL.  */
4298
4299 void
4300 start_init (tree decl, tree asmspec_tree, int top_level)
4301 {
4302   const char *locus;
4303   struct initializer_stack *p = XNEW (struct initializer_stack);
4304   const char *asmspec = 0;
4305
4306   if (asmspec_tree)
4307     asmspec = TREE_STRING_POINTER (asmspec_tree);
4308
4309   p->decl = constructor_decl;
4310   p->asmspec = constructor_asmspec;
4311   p->require_constant_value = require_constant_value;
4312   p->require_constant_elements = require_constant_elements;
4313   p->constructor_stack = constructor_stack;
4314   p->constructor_range_stack = constructor_range_stack;
4315   p->elements = constructor_elements;
4316   p->spelling = spelling;
4317   p->spelling_base = spelling_base;
4318   p->spelling_size = spelling_size;
4319   p->top_level = constructor_top_level;
4320   p->next = initializer_stack;
4321   initializer_stack = p;
4322
4323   constructor_decl = decl;
4324   constructor_asmspec = asmspec;
4325   constructor_designated = 0;
4326   constructor_top_level = top_level;
4327
4328   if (decl != 0)
4329     {
4330       require_constant_value = TREE_STATIC (decl);
4331       require_constant_elements
4332         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4333            /* For a scalar, you can always use any value to initialize,
4334               even within braces.  */
4335            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4336                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4337                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4338                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4339       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4340     }
4341   else
4342     {
4343       require_constant_value = 0;
4344       require_constant_elements = 0;
4345       locus = "(anonymous)";
4346     }
4347
4348   constructor_stack = 0;
4349   constructor_range_stack = 0;
4350
4351   missing_braces_mentioned = 0;
4352
4353   spelling_base = 0;
4354   spelling_size = 0;
4355   RESTORE_SPELLING_DEPTH (0);
4356
4357   if (locus)
4358     push_string (locus);
4359 }
4360
4361 void
4362 finish_init (void)
4363 {
4364   struct initializer_stack *p = initializer_stack;
4365
4366   /* Free the whole constructor stack of this initializer.  */
4367   while (constructor_stack)
4368     {
4369       struct constructor_stack *q = constructor_stack;
4370       constructor_stack = q->next;
4371       free (q);
4372     }
4373
4374   if (constructor_range_stack)
4375     abort ();
4376
4377   /* Pop back to the data of the outer initializer (if any).  */
4378   free (spelling_base);
4379
4380   constructor_decl = p->decl;
4381   constructor_asmspec = p->asmspec;
4382   require_constant_value = p->require_constant_value;
4383   require_constant_elements = p->require_constant_elements;
4384   constructor_stack = p->constructor_stack;
4385   constructor_range_stack = p->constructor_range_stack;
4386   constructor_elements = p->elements;
4387   spelling = p->spelling;
4388   spelling_base = p->spelling_base;
4389   spelling_size = p->spelling_size;
4390   constructor_top_level = p->top_level;
4391   initializer_stack = p->next;
4392   free (p);
4393 }
4394 \f
4395 /* Call here when we see the initializer is surrounded by braces.
4396    This is instead of a call to push_init_level;
4397    it is matched by a call to pop_init_level.
4398
4399    TYPE is the type to initialize, for a constructor expression.
4400    For an initializer for a decl, TYPE is zero.  */
4401
4402 void
4403 really_start_incremental_init (tree type)
4404 {
4405   struct constructor_stack *p = XNEW (struct constructor_stack);
4406
4407   if (type == 0)
4408     type = TREE_TYPE (constructor_decl);
4409
4410   if (targetm.vector_opaque_p (type))
4411     error ("opaque vector types cannot be initialized");
4412
4413   p->type = constructor_type;
4414   p->fields = constructor_fields;
4415   p->index = constructor_index;
4416   p->max_index = constructor_max_index;
4417   p->unfilled_index = constructor_unfilled_index;
4418   p->unfilled_fields = constructor_unfilled_fields;
4419   p->bit_index = constructor_bit_index;
4420   p->elements = constructor_elements;
4421   p->constant = constructor_constant;
4422   p->simple = constructor_simple;
4423   p->erroneous = constructor_erroneous;
4424   p->pending_elts = constructor_pending_elts;
4425   p->depth = constructor_depth;
4426   p->replacement_value.value = 0;
4427   p->replacement_value.original_code = ERROR_MARK;
4428   p->implicit = 0;
4429   p->range_stack = 0;
4430   p->outer = 0;
4431   p->incremental = constructor_incremental;
4432   p->designated = constructor_designated;
4433   p->next = 0;
4434   constructor_stack = p;
4435
4436   constructor_constant = 1;
4437   constructor_simple = 1;
4438   constructor_depth = SPELLING_DEPTH ();
4439   constructor_elements = 0;
4440   constructor_pending_elts = 0;
4441   constructor_type = type;
4442   constructor_incremental = 1;
4443   constructor_designated = 0;
4444   designator_depth = 0;
4445   designator_errorneous = 0;
4446
4447   if (TREE_CODE (constructor_type) == RECORD_TYPE
4448       || TREE_CODE (constructor_type) == UNION_TYPE)
4449     {
4450       constructor_fields = TYPE_FIELDS (constructor_type);
4451       /* Skip any nameless bit fields at the beginning.  */
4452       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4453              && DECL_NAME (constructor_fields) == 0)
4454         constructor_fields = TREE_CHAIN (constructor_fields);
4455
4456       constructor_unfilled_fields = constructor_fields;
4457       constructor_bit_index = bitsize_zero_node;
4458     }
4459   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4460     {
4461       if (TYPE_DOMAIN (constructor_type))
4462         {
4463           constructor_max_index
4464             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4465
4466           /* Detect non-empty initializations of zero-length arrays.  */
4467           if (constructor_max_index == NULL_TREE
4468               && TYPE_SIZE (constructor_type))
4469             constructor_max_index = build_int_cst (NULL_TREE, -1);
4470
4471           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4472              to initialize VLAs will cause a proper error; avoid tree
4473              checking errors as well by setting a safe value.  */
4474           if (constructor_max_index
4475               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4476             constructor_max_index = build_int_cst (NULL_TREE, -1);
4477
4478           constructor_index
4479             = convert (bitsizetype,
4480                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4481         }
4482       else
4483         constructor_index = bitsize_zero_node;
4484
4485       constructor_unfilled_index = constructor_index;
4486     }
4487   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4488     {
4489       /* Vectors are like simple fixed-size arrays.  */
4490       constructor_max_index =
4491         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4492       constructor_index = convert (bitsizetype, bitsize_zero_node);
4493       constructor_unfilled_index = constructor_index;
4494     }
4495   else
4496     {
4497       /* Handle the case of int x = {5}; */
4498       constructor_fields = constructor_type;
4499       constructor_unfilled_fields = constructor_type;
4500     }
4501 }
4502 \f
4503 /* Push down into a subobject, for initialization.
4504    If this is for an explicit set of braces, IMPLICIT is 0.
4505    If it is because the next element belongs at a lower level,
4506    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4507
4508 void
4509 push_init_level (int implicit)
4510 {
4511   struct constructor_stack *p;
4512   tree value = NULL_TREE;
4513
4514   /* If we've exhausted any levels that didn't have braces,
4515      pop them now.  */
4516   while (constructor_stack->implicit)
4517     {
4518       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4519            || TREE_CODE (constructor_type) == UNION_TYPE)
4520           && constructor_fields == 0)
4521         process_init_element (pop_init_level (1));
4522       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4523                && constructor_max_index
4524                && tree_int_cst_lt (constructor_max_index, constructor_index))
4525         process_init_element (pop_init_level (1));
4526       else
4527         break;
4528     }
4529
4530   /* Unless this is an explicit brace, we need to preserve previous
4531      content if any.  */
4532   if (implicit)
4533     {
4534       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4535            || TREE_CODE (constructor_type) == UNION_TYPE)
4536           && constructor_fields)
4537         value = find_init_member (constructor_fields);
4538       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4539         value = find_init_member (constructor_index);
4540     }
4541
4542   p = XNEW (struct constructor_stack);
4543   p->type = constructor_type;
4544   p->fields = constructor_fields;
4545   p->index = constructor_index;
4546   p->max_index = constructor_max_index;
4547   p->unfilled_index = constructor_unfilled_index;
4548   p->unfilled_fields = constructor_unfilled_fields;
4549   p->bit_index = constructor_bit_index;
4550   p->elements = constructor_elements;
4551   p->constant = constructor_constant;
4552   p->simple = constructor_simple;
4553   p->erroneous = constructor_erroneous;
4554   p->pending_elts = constructor_pending_elts;
4555   p->depth = constructor_depth;
4556   p->replacement_value.value = 0;
4557   p->replacement_value.original_code = ERROR_MARK;
4558   p->implicit = implicit;
4559   p->outer = 0;
4560   p->incremental = constructor_incremental;
4561   p->designated = constructor_designated;
4562   p->next = constructor_stack;
4563   p->range_stack = 0;
4564   constructor_stack = p;
4565
4566   constructor_constant = 1;
4567   constructor_simple = 1;
4568   constructor_depth = SPELLING_DEPTH ();
4569   constructor_elements = 0;
4570   constructor_incremental = 1;
4571   constructor_designated = 0;
4572   constructor_pending_elts = 0;
4573   if (!implicit)
4574     {
4575       p->range_stack = constructor_range_stack;
4576       constructor_range_stack = 0;
4577       designator_depth = 0;
4578       designator_errorneous = 0;
4579     }
4580
4581   /* Don't die if an entire brace-pair level is superfluous
4582      in the containing level.  */
4583   if (constructor_type == 0)
4584     ;
4585   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4586            || TREE_CODE (constructor_type) == UNION_TYPE)
4587     {
4588       /* Don't die if there are extra init elts at the end.  */
4589       if (constructor_fields == 0)
4590         constructor_type = 0;
4591       else
4592         {
4593           constructor_type = TREE_TYPE (constructor_fields);
4594           push_member_name (constructor_fields);
4595           constructor_depth++;
4596         }
4597     }
4598   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4599     {
4600       constructor_type = TREE_TYPE (constructor_type);
4601       push_array_bounds (tree_low_cst (constructor_index, 0));
4602       constructor_depth++;
4603     }
4604
4605   if (constructor_type == 0)
4606     {
4607       error_init ("extra brace group at end of initializer");
4608       constructor_fields = 0;
4609       constructor_unfilled_fields = 0;
4610       return;
4611     }
4612
4613   if (value && TREE_CODE (value) == CONSTRUCTOR)
4614     {
4615       constructor_constant = TREE_CONSTANT (value);
4616       constructor_simple = TREE_STATIC (value);
4617       constructor_elements = CONSTRUCTOR_ELTS (value);
4618       if (constructor_elements
4619           && (TREE_CODE (constructor_type) == RECORD_TYPE
4620               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4621         set_nonincremental_init ();
4622     }
4623
4624   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4625     {
4626       missing_braces_mentioned = 1;
4627       warning_init ("missing braces around initializer");
4628     }
4629
4630   if (TREE_CODE (constructor_type) == RECORD_TYPE
4631            || TREE_CODE (constructor_type) == UNION_TYPE)
4632     {
4633       constructor_fields = TYPE_FIELDS (constructor_type);
4634       /* Skip any nameless bit fields at the beginning.  */
4635       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4636              && DECL_NAME (constructor_fields) == 0)
4637         constructor_fields = TREE_CHAIN (constructor_fields);
4638
4639       constructor_unfilled_fields = constructor_fields;
4640       constructor_bit_index = bitsize_zero_node;
4641     }
4642   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4643     {
4644       /* Vectors are like simple fixed-size arrays.  */
4645       constructor_max_index =
4646         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4647       constructor_index = convert (bitsizetype, integer_zero_node);
4648       constructor_unfilled_index = constructor_index;
4649     }
4650   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4651     {
4652       if (TYPE_DOMAIN (constructor_type))
4653         {
4654           constructor_max_index
4655             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4656
4657           /* Detect non-empty initializations of zero-length arrays.  */
4658           if (constructor_max_index == NULL_TREE
4659               && TYPE_SIZE (constructor_type))
4660             constructor_max_index = build_int_cst (NULL_TREE, -1);
4661
4662           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4663              to initialize VLAs will cause a proper error; avoid tree
4664              checking errors as well by setting a safe value.  */
4665           if (constructor_max_index
4666               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4667             constructor_max_index = build_int_cst (NULL_TREE, -1);
4668
4669           constructor_index
4670             = convert (bitsizetype,
4671                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4672         }
4673       else
4674         constructor_index = bitsize_zero_node;
4675
4676       constructor_unfilled_index = constructor_index;
4677       if (value && TREE_CODE (value) == STRING_CST)
4678         {
4679           /* We need to split the char/wchar array into individual
4680              characters, so that we don't have to special case it
4681              everywhere.  */
4682           set_nonincremental_init_from_string (value);
4683         }
4684     }
4685   else
4686     {
4687       warning_init ("braces around scalar initializer");
4688       constructor_fields = constructor_type;
4689       constructor_unfilled_fields = constructor_type;
4690     }
4691 }
4692
4693 /* At the end of an implicit or explicit brace level,
4694    finish up that level of constructor.  If a single expression
4695    with redundant braces initialized that level, return the
4696    c_expr structure for that expression.  Otherwise, the original_code
4697    element is set to ERROR_MARK.
4698    If we were outputting the elements as they are read, return 0 as the value
4699    from inner levels (process_init_element ignores that),
4700    but return error_mark_node as the value from the outermost level
4701    (that's what we want to put in DECL_INITIAL).
4702    Otherwise, return a CONSTRUCTOR expression as the value.  */
4703
4704 struct c_expr
4705 pop_init_level (int implicit)
4706 {
4707   struct constructor_stack *p;
4708   struct c_expr ret;
4709   ret.value = 0;
4710   ret.original_code = ERROR_MARK;
4711
4712   if (implicit == 0)
4713     {
4714       /* When we come to an explicit close brace,
4715          pop any inner levels that didn't have explicit braces.  */
4716       while (constructor_stack->implicit)
4717         process_init_element (pop_init_level (1));
4718
4719       if (constructor_range_stack)
4720         abort ();
4721     }
4722
4723   /* Now output all pending elements.  */
4724   constructor_incremental = 1;
4725   output_pending_init_elements (1);
4726
4727   p = constructor_stack;
4728
4729   /* Error for initializing a flexible array member, or a zero-length
4730      array member in an inappropriate context.  */
4731   if (constructor_type && constructor_fields
4732       && TREE_CODE (constructor_type) == ARRAY_TYPE
4733       && TYPE_DOMAIN (constructor_type)
4734       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4735     {
4736       /* Silently discard empty initializations.  The parser will
4737          already have pedwarned for empty brackets.  */
4738       if (integer_zerop (constructor_unfilled_index))
4739         constructor_type = NULL_TREE;
4740       else if (! TYPE_SIZE (constructor_type))
4741         {
4742           if (constructor_depth > 2)
4743             error_init ("initialization of flexible array member in a nested context");
4744           else if (pedantic)
4745             pedwarn_init ("initialization of a flexible array member");
4746
4747           /* We have already issued an error message for the existence
4748              of a flexible array member not at the end of the structure.
4749              Discard the initializer so that we do not abort later.  */
4750           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4751             constructor_type = NULL_TREE;
4752         }
4753       else
4754         /* Zero-length arrays are no longer special, so we should no longer
4755            get here.  */
4756         abort ();
4757     }
4758
4759   /* Warn when some struct elements are implicitly initialized to zero.  */
4760   if (warn_missing_field_initializers
4761       && constructor_type
4762       && TREE_CODE (constructor_type) == RECORD_TYPE
4763       && constructor_unfilled_fields)
4764     {
4765         /* Do not warn for flexible array members or zero-length arrays.  */
4766         while (constructor_unfilled_fields
4767                && (! DECL_SIZE (constructor_unfilled_fields)
4768                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4769           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4770
4771         /* Do not warn if this level of the initializer uses member
4772            designators; it is likely to be deliberate.  */
4773         if (constructor_unfilled_fields && !constructor_designated)
4774           {
4775             push_member_name (constructor_unfilled_fields);
4776             warning_init ("missing initializer");
4777             RESTORE_SPELLING_DEPTH (constructor_depth);
4778           }
4779     }
4780
4781   /* Pad out the end of the structure.  */
4782   if (p->replacement_value.value)
4783     /* If this closes a superfluous brace pair,
4784        just pass out the element between them.  */
4785     ret = p->replacement_value;
4786   else if (constructor_type == 0)
4787     ;
4788   else if (TREE_CODE (constructor_type) != RECORD_TYPE
4789            && TREE_CODE (constructor_type) != UNION_TYPE
4790            && TREE_CODE (constructor_type) != ARRAY_TYPE
4791            && TREE_CODE (constructor_type) != VECTOR_TYPE)
4792     {
4793       /* A nonincremental scalar initializer--just return
4794          the element, after verifying there is just one.  */
4795       if (constructor_elements == 0)
4796         {
4797           if (!constructor_erroneous)
4798             error_init ("empty scalar initializer");
4799           ret.value = error_mark_node;
4800         }
4801       else if (TREE_CHAIN (constructor_elements) != 0)
4802         {
4803           error_init ("extra elements in scalar initializer");
4804           ret.value = TREE_VALUE (constructor_elements);
4805         }
4806       else
4807         ret.value = TREE_VALUE (constructor_elements);
4808     }
4809   else
4810     {
4811       if (constructor_erroneous)
4812         ret.value = error_mark_node;
4813       else
4814         {
4815           ret.value = build_constructor (constructor_type,
4816                                          nreverse (constructor_elements));
4817           if (constructor_constant)
4818             TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
4819           if (constructor_constant && constructor_simple)
4820             TREE_STATIC (ret.value) = 1;
4821         }
4822     }
4823
4824   constructor_type = p->type;
4825   constructor_fields = p->fields;
4826   constructor_index = p->index;
4827   constructor_max_index = p->max_index;
4828   constructor_unfilled_index = p->unfilled_index;
4829   constructor_unfilled_fields = p->unfilled_fields;
4830   constructor_bit_index = p->bit_index;
4831   constructor_elements = p->elements;
4832   constructor_constant = p->constant;
4833   constructor_simple = p->simple;
4834   constructor_erroneous = p->erroneous;
4835   constructor_incremental = p->incremental;
4836   constructor_designated = p->designated;
4837   constructor_pending_elts = p->pending_elts;
4838   constructor_depth = p->depth;
4839   if (!p->implicit)
4840     constructor_range_stack = p->range_stack;
4841   RESTORE_SPELLING_DEPTH (constructor_depth);
4842
4843   constructor_stack = p->next;
4844   free (p);
4845
4846   if (ret.value == 0)
4847     {
4848       if (constructor_stack == 0)
4849         {
4850           ret.value = error_mark_node;
4851           return ret;
4852         }
4853       return ret;
4854     }
4855   return ret;
4856 }
4857
4858 /* Common handling for both array range and field name designators.
4859    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
4860
4861 static int
4862 set_designator (int array)
4863 {
4864   tree subtype;
4865   enum tree_code subcode;
4866
4867   /* Don't die if an entire brace-pair level is superfluous
4868      in the containing level.  */
4869   if (constructor_type == 0)
4870     return 1;
4871
4872   /* If there were errors in this designator list already, bail out silently.  */
4873   if (designator_errorneous)
4874     return 1;
4875
4876   if (!designator_depth)
4877     {
4878       if (constructor_range_stack)
4879         abort ();
4880
4881       /* Designator list starts at the level of closest explicit
4882          braces.  */
4883       while (constructor_stack->implicit)
4884         process_init_element (pop_init_level (1));
4885       constructor_designated = 1;
4886       return 0;
4887     }
4888
4889   if (constructor_no_implicit)
4890     {
4891       error_init ("initialization designators may not nest");
4892       return 1;
4893     }
4894
4895   if (TREE_CODE (constructor_type) == RECORD_TYPE
4896       || TREE_CODE (constructor_type) == UNION_TYPE)
4897     {
4898       subtype = TREE_TYPE (constructor_fields);
4899       if (subtype != error_mark_node)
4900         subtype = TYPE_MAIN_VARIANT (subtype);
4901     }
4902   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4903     {
4904       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
4905     }
4906   else
4907     abort ();
4908
4909   subcode = TREE_CODE (subtype);
4910   if (array && subcode != ARRAY_TYPE)
4911     {
4912       error_init ("array index in non-array initializer");
4913       return 1;
4914     }
4915   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
4916     {
4917       error_init ("field name not in record or union initializer");
4918       return 1;
4919     }
4920
4921   constructor_designated = 1;
4922   push_init_level (2);
4923   return 0;
4924 }
4925
4926 /* If there are range designators in designator list, push a new designator
4927    to constructor_range_stack.  RANGE_END is end of such stack range or
4928    NULL_TREE if there is no range designator at this level.  */
4929
4930 static void
4931 push_range_stack (tree range_end)
4932 {
4933   struct constructor_range_stack *p;
4934
4935   p = GGC_NEW (struct constructor_range_stack);
4936   p->prev = constructor_range_stack;
4937   p->next = 0;
4938   p->fields = constructor_fields;
4939   p->range_start = constructor_index;
4940   p->index = constructor_index;
4941   p->stack = constructor_stack;
4942   p->range_end = range_end;
4943   if (constructor_range_stack)
4944     constructor_range_stack->next = p;
4945   constructor_range_stack = p;
4946 }
4947
4948 /* Within an array initializer, specify the next index to be initialized.
4949    FIRST is that index.  If LAST is nonzero, then initialize a range
4950    of indices, running from FIRST through LAST.  */
4951
4952 void
4953 set_init_index (tree first, tree last)
4954 {
4955   if (set_designator (1))
4956     return;
4957
4958   designator_errorneous = 1;
4959
4960   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
4961       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
4962     {
4963       error_init ("array index in initializer not of integer type");
4964       return;
4965     }
4966
4967   while ((TREE_CODE (first) == NOP_EXPR
4968           || TREE_CODE (first) == CONVERT_EXPR
4969           || TREE_CODE (first) == NON_LVALUE_EXPR)
4970          && (TYPE_MODE (TREE_TYPE (first))
4971              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
4972     first = TREE_OPERAND (first, 0);
4973
4974   if (last)
4975     while ((TREE_CODE (last) == NOP_EXPR
4976             || TREE_CODE (last) == CONVERT_EXPR
4977             || TREE_CODE (last) == NON_LVALUE_EXPR)
4978            && (TYPE_MODE (TREE_TYPE (last))
4979                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
4980       last = TREE_OPERAND (last, 0);
4981
4982   if (TREE_CODE (first) != INTEGER_CST)
4983     error_init ("nonconstant array index in initializer");
4984   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
4985     error_init ("nonconstant array index in initializer");
4986   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
4987     error_init ("array index in non-array initializer");
4988   else if (tree_int_cst_sgn (first) == -1)
4989     error_init ("array index in initializer exceeds array bounds");
4990   else if (constructor_max_index
4991            && tree_int_cst_lt (constructor_max_index, first))
4992     error_init ("array index in initializer exceeds array bounds");
4993   else
4994     {
4995       constructor_index = convert (bitsizetype, first);
4996
4997       if (last)
4998         {
4999           if (tree_int_cst_equal (first, last))
5000             last = 0;
5001           else if (tree_int_cst_lt (last, first))
5002             {
5003               error_init ("empty index range in initializer");
5004               last = 0;
5005             }
5006           else
5007             {
5008               last = convert (bitsizetype, last);
5009               if (constructor_max_index != 0
5010                   && tree_int_cst_lt (constructor_max_index, last))
5011                 {
5012                   error_init ("array index range in initializer exceeds array bounds");
5013                   last = 0;
5014                 }
5015             }
5016         }
5017
5018       designator_depth++;
5019       designator_errorneous = 0;
5020       if (constructor_range_stack || last)
5021         push_range_stack (last);
5022     }
5023 }
5024
5025 /* Within a struct initializer, specify the next field to be initialized.  */
5026
5027 void
5028 set_init_label (tree fieldname)
5029 {
5030   tree tail;
5031
5032   if (set_designator (0))
5033     return;
5034
5035   designator_errorneous = 1;
5036
5037   if (TREE_CODE (constructor_type) != RECORD_TYPE
5038       && TREE_CODE (constructor_type) != UNION_TYPE)
5039     {
5040       error_init ("field name not in record or union initializer");
5041       return;
5042     }
5043
5044   for (tail = TYPE_FIELDS (constructor_type); tail;
5045        tail = TREE_CHAIN (tail))
5046     {
5047       if (DECL_NAME (tail) == fieldname)
5048         break;
5049     }
5050
5051   if (tail == 0)
5052     error ("unknown field `%s' specified in initializer",
5053            IDENTIFIER_POINTER (fieldname));
5054   else
5055     {
5056       constructor_fields = tail;
5057       designator_depth++;
5058       designator_errorneous = 0;
5059       if (constructor_range_stack)
5060         push_range_stack (NULL_TREE);
5061     }
5062 }
5063 \f
5064 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5065    identifies the initializer, either array index or field in a structure.
5066    VALUE is the value of that index or field.  */
5067
5068 static void
5069 add_pending_init (tree purpose, tree value)
5070 {
5071   struct init_node *p, **q, *r;
5072
5073   q = &constructor_pending_elts;
5074   p = 0;
5075
5076   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5077     {
5078       while (*q != 0)
5079         {
5080           p = *q;
5081           if (tree_int_cst_lt (purpose, p->purpose))
5082             q = &p->left;
5083           else if (tree_int_cst_lt (p->purpose, purpose))
5084             q = &p->right;
5085           else
5086             {
5087               if (TREE_SIDE_EFFECTS (p->value))
5088                 warning_init ("initialized field with side-effects overwritten");
5089               p->value = value;
5090               return;
5091             }
5092         }
5093     }
5094   else
5095     {
5096       tree bitpos;
5097
5098       bitpos = bit_position (purpose);
5099       while (*q != NULL)
5100         {
5101           p = *q;
5102           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5103             q = &p->left;
5104           else if (p->purpose != purpose)
5105             q = &p->right;
5106           else
5107             {
5108               if (TREE_SIDE_EFFECTS (p->value))
5109                 warning_init ("initialized field with side-effects overwritten");
5110               p->value = value;
5111               return;
5112             }
5113         }
5114     }
5115
5116   r = GGC_NEW (struct init_node);
5117   r->purpose = purpose;
5118   r->value = value;
5119
5120   *q = r;
5121   r->parent = p;
5122   r->left = 0;
5123   r->right = 0;
5124   r->balance = 0;
5125
5126   while (p)
5127     {
5128       struct init_node *s;
5129
5130       if (r == p->left)
5131         {
5132           if (p->balance == 0)
5133             p->balance = -1;
5134           else if (p->balance < 0)
5135             {
5136               if (r->balance < 0)
5137                 {
5138                   /* L rotation.  */
5139                   p->left = r->right;
5140                   if (p->left)
5141                     p->left->parent = p;
5142                   r->right = p;
5143
5144                   p->balance = 0;
5145                   r->balance = 0;
5146
5147                   s = p->parent;
5148                   p->parent = r;
5149                   r->parent = s;
5150                   if (s)
5151                     {
5152                       if (s->left == p)
5153                         s->left = r;
5154                       else
5155                         s->right = r;
5156                     }
5157                   else
5158                     constructor_pending_elts = r;
5159                 }
5160               else
5161                 {
5162                   /* LR rotation.  */
5163                   struct init_node *t = r->right;
5164
5165                   r->right = t->left;
5166                   if (r->right)
5167                     r->right->parent = r;
5168                   t->left = r;
5169
5170                   p->left = t->right;
5171                   if (p->left)
5172                     p->left->parent = p;
5173                   t->right = p;
5174
5175                   p->balance = t->balance < 0;
5176                   r->balance = -(t->balance > 0);
5177                   t->balance = 0;
5178
5179                   s = p->parent;
5180                   p->parent = t;
5181                   r->parent = t;
5182                   t->parent = s;
5183                   if (s)
5184                     {
5185                       if (s->left == p)
5186                         s->left = t;
5187                       else
5188                         s->right = t;
5189                     }
5190                   else
5191                     constructor_pending_elts = t;
5192                 }
5193               break;
5194             }
5195           else
5196             {
5197               /* p->balance == +1; growth of left side balances the node.  */
5198               p->balance = 0;
5199               break;
5200             }
5201         }
5202       else /* r == p->right */
5203         {
5204           if (p->balance == 0)
5205             /* Growth propagation from right side.  */
5206             p->balance++;
5207           else if (p->balance > 0)
5208             {
5209               if (r->balance > 0)
5210                 {
5211                   /* R rotation.  */
5212                   p->right = r->left;
5213                   if (p->right)
5214                     p->right->parent = p;
5215                   r->left = p;
5216
5217                   p->balance = 0;
5218                   r->balance = 0;
5219
5220                   s = p->parent;
5221                   p->parent = r;
5222                   r->parent = s;
5223                   if (s)
5224                     {
5225                       if (s->left == p)
5226                         s->left = r;
5227                       else
5228                         s->right = r;
5229                     }
5230                   else
5231                     constructor_pending_elts = r;
5232                 }
5233               else /* r->balance == -1 */
5234                 {
5235                   /* RL rotation */
5236                   struct init_node *t = r->left;
5237
5238                   r->left = t->right;
5239                   if (r->left)
5240                     r->left->parent = r;
5241                   t->right = r;
5242
5243                   p->right = t->left;
5244                   if (p->right)
5245                     p->right->parent = p;
5246                   t->left = p;
5247
5248                   r->balance = (t->balance < 0);
5249                   p->balance = -(t->balance > 0);
5250                   t->balance = 0;
5251
5252                   s = p->parent;
5253                   p->parent = t;
5254                   r->parent = t;
5255                   t->parent = s;
5256                   if (s)
5257                     {
5258                       if (s->left == p)
5259                         s->left = t;
5260                       else
5261                         s->right = t;
5262                     }
5263                   else
5264                     constructor_pending_elts = t;
5265                 }
5266               break;
5267             }
5268           else
5269             {
5270               /* p->balance == -1; growth of right side balances the node.  */
5271               p->balance = 0;
5272               break;
5273             }
5274         }
5275
5276       r = p;
5277       p = p->parent;
5278     }
5279 }
5280
5281 /* Build AVL tree from a sorted chain.  */
5282
5283 static void
5284 set_nonincremental_init (void)
5285 {
5286   tree chain;
5287
5288   if (TREE_CODE (constructor_type) != RECORD_TYPE
5289       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5290     return;
5291
5292   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5293     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5294   constructor_elements = 0;
5295   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5296     {
5297       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5298       /* Skip any nameless bit fields at the beginning.  */
5299       while (constructor_unfilled_fields != 0
5300              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5301              && DECL_NAME (constructor_unfilled_fields) == 0)
5302         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5303
5304     }
5305   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5306     {
5307       if (TYPE_DOMAIN (constructor_type))
5308         constructor_unfilled_index
5309             = convert (bitsizetype,
5310                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5311       else
5312         constructor_unfilled_index = bitsize_zero_node;
5313     }
5314   constructor_incremental = 0;
5315 }
5316
5317 /* Build AVL tree from a string constant.  */
5318
5319 static void
5320 set_nonincremental_init_from_string (tree str)
5321 {
5322   tree value, purpose, type;
5323   HOST_WIDE_INT val[2];
5324   const char *p, *end;
5325   int byte, wchar_bytes, charwidth, bitpos;
5326
5327   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5328     abort ();
5329
5330   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5331       == TYPE_PRECISION (char_type_node))
5332     wchar_bytes = 1;
5333   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5334            == TYPE_PRECISION (wchar_type_node))
5335     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5336   else
5337     abort ();
5338
5339   charwidth = TYPE_PRECISION (char_type_node);
5340   type = TREE_TYPE (constructor_type);
5341   p = TREE_STRING_POINTER (str);
5342   end = p + TREE_STRING_LENGTH (str);
5343
5344   for (purpose = bitsize_zero_node;
5345        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5346        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5347     {
5348       if (wchar_bytes == 1)
5349         {
5350           val[1] = (unsigned char) *p++;
5351           val[0] = 0;
5352         }
5353       else
5354         {
5355           val[0] = 0;
5356           val[1] = 0;
5357           for (byte = 0; byte < wchar_bytes; byte++)
5358             {
5359               if (BYTES_BIG_ENDIAN)
5360                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5361               else
5362                 bitpos = byte * charwidth;
5363               val[bitpos < HOST_BITS_PER_WIDE_INT]
5364                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5365                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5366             }
5367         }
5368
5369       if (!TYPE_UNSIGNED (type))
5370         {
5371           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5372           if (bitpos < HOST_BITS_PER_WIDE_INT)
5373             {
5374               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5375                 {
5376                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5377                   val[0] = -1;
5378                 }
5379             }
5380           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5381             {
5382               if (val[1] < 0)
5383                 val[0] = -1;
5384             }
5385           else if (val[0] & (((HOST_WIDE_INT) 1)
5386                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5387             val[0] |= ((HOST_WIDE_INT) -1)
5388                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5389         }
5390
5391       value = build_int_cst_wide (type, val[1], val[0]);
5392       add_pending_init (purpose, value);
5393     }
5394
5395   constructor_incremental = 0;
5396 }
5397
5398 /* Return value of FIELD in pending initializer or zero if the field was
5399    not initialized yet.  */
5400
5401 static tree
5402 find_init_member (tree field)
5403 {
5404   struct init_node *p;
5405
5406   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5407     {
5408       if (constructor_incremental
5409           && tree_int_cst_lt (field, constructor_unfilled_index))
5410         set_nonincremental_init ();
5411
5412       p = constructor_pending_elts;
5413       while (p)
5414         {
5415           if (tree_int_cst_lt (field, p->purpose))
5416             p = p->left;
5417           else if (tree_int_cst_lt (p->purpose, field))
5418             p = p->right;
5419           else
5420             return p->value;
5421         }
5422     }
5423   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5424     {
5425       tree bitpos = bit_position (field);
5426
5427       if (constructor_incremental
5428           && (!constructor_unfilled_fields
5429               || tree_int_cst_lt (bitpos,
5430                                   bit_position (constructor_unfilled_fields))))
5431         set_nonincremental_init ();
5432
5433       p = constructor_pending_elts;
5434       while (p)
5435         {
5436           if (field == p->purpose)
5437             return p->value;
5438           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5439             p = p->left;
5440           else
5441             p = p->right;
5442         }
5443     }
5444   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5445     {
5446       if (constructor_elements
5447           && TREE_PURPOSE (constructor_elements) == field)
5448         return TREE_VALUE (constructor_elements);
5449     }
5450   return 0;
5451 }
5452
5453 /* "Output" the next constructor element.
5454    At top level, really output it to assembler code now.
5455    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5456    TYPE is the data type that the containing data type wants here.
5457    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5458    If VALUE is a string constant, STRICT_STRING is true if it is
5459    unparenthesized or we should not warn here for it being parenthesized.
5460    For other types of VALUE, STRICT_STRING is not used.
5461
5462    PENDING if non-nil means output pending elements that belong
5463    right after this element.  (PENDING is normally 1;
5464    it is 0 while outputting pending elements, to avoid recursion.)  */
5465
5466 static void
5467 output_init_element (tree value, bool strict_string, tree type, tree field,
5468                      int pending)
5469 {
5470   if (type == error_mark_node)
5471     {
5472       constructor_erroneous = 1;
5473       return;
5474     }
5475   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5476       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5477           && !(TREE_CODE (value) == STRING_CST
5478                && TREE_CODE (type) == ARRAY_TYPE
5479                && INTEGRAL_TYPE_P (TREE_TYPE (type)))
5480           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5481                          TYPE_MAIN_VARIANT (type))))
5482     value = default_conversion (value);
5483
5484   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5485       && require_constant_value && !flag_isoc99 && pending)
5486     {
5487       /* As an extension, allow initializing objects with static storage
5488          duration with compound literals (which are then treated just as
5489          the brace enclosed list they contain).  */
5490       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5491       value = DECL_INITIAL (decl);
5492     }
5493
5494   if (value == error_mark_node)
5495     constructor_erroneous = 1;
5496   else if (!TREE_CONSTANT (value))
5497     constructor_constant = 0;
5498   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5499            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5500                 || TREE_CODE (constructor_type) == UNION_TYPE)
5501                && DECL_C_BIT_FIELD (field)
5502                && TREE_CODE (value) != INTEGER_CST))
5503     constructor_simple = 0;
5504
5505   if (require_constant_value && ! TREE_CONSTANT (value))
5506     {
5507       error_init ("initializer element is not constant");
5508       value = error_mark_node;
5509     }
5510   else if (require_constant_elements
5511            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5512     pedwarn ("initializer element is not computable at load time");
5513
5514   /* If this field is empty (and not at the end of structure),
5515      don't do anything other than checking the initializer.  */
5516   if (field
5517       && (TREE_TYPE (field) == error_mark_node
5518           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5519               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5520               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5521                   || TREE_CHAIN (field)))))
5522     return;
5523
5524   value = digest_init (type, value, strict_string, require_constant_value);
5525   if (value == error_mark_node)
5526     {
5527       constructor_erroneous = 1;
5528       return;
5529     }
5530
5531   /* If this element doesn't come next in sequence,
5532      put it on constructor_pending_elts.  */
5533   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5534       && (!constructor_incremental
5535           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5536     {
5537       if (constructor_incremental
5538           && tree_int_cst_lt (field, constructor_unfilled_index))
5539         set_nonincremental_init ();
5540
5541       add_pending_init (field, value);
5542       return;
5543     }
5544   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5545            && (!constructor_incremental
5546                || field != constructor_unfilled_fields))
5547     {
5548       /* We do this for records but not for unions.  In a union,
5549          no matter which field is specified, it can be initialized
5550          right away since it starts at the beginning of the union.  */
5551       if (constructor_incremental)
5552         {
5553           if (!constructor_unfilled_fields)
5554             set_nonincremental_init ();
5555           else
5556             {
5557               tree bitpos, unfillpos;
5558
5559               bitpos = bit_position (field);
5560               unfillpos = bit_position (constructor_unfilled_fields);
5561
5562               if (tree_int_cst_lt (bitpos, unfillpos))
5563                 set_nonincremental_init ();
5564             }
5565         }
5566
5567       add_pending_init (field, value);
5568       return;
5569     }
5570   else if (TREE_CODE (constructor_type) == UNION_TYPE
5571            && constructor_elements)
5572     {
5573       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5574         warning_init ("initialized field with side-effects overwritten");
5575
5576       /* We can have just one union field set.  */
5577       constructor_elements = 0;
5578     }
5579
5580   /* Otherwise, output this element either to
5581      constructor_elements or to the assembler file.  */
5582
5583   if (field && TREE_CODE (field) == INTEGER_CST)
5584     field = copy_node (field);
5585   constructor_elements
5586     = tree_cons (field, value, constructor_elements);
5587
5588   /* Advance the variable that indicates sequential elements output.  */
5589   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5590     constructor_unfilled_index
5591       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5592                     bitsize_one_node);
5593   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5594     {
5595       constructor_unfilled_fields
5596         = TREE_CHAIN (constructor_unfilled_fields);
5597
5598       /* Skip any nameless bit fields.  */
5599       while (constructor_unfilled_fields != 0
5600              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5601              && DECL_NAME (constructor_unfilled_fields) == 0)
5602         constructor_unfilled_fields =
5603           TREE_CHAIN (constructor_unfilled_fields);
5604     }
5605   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5606     constructor_unfilled_fields = 0;
5607
5608   /* Now output any pending elements which have become next.  */
5609   if (pending)
5610     output_pending_init_elements (0);
5611 }
5612
5613 /* Output any pending elements which have become next.
5614    As we output elements, constructor_unfilled_{fields,index}
5615    advances, which may cause other elements to become next;
5616    if so, they too are output.
5617
5618    If ALL is 0, we return when there are
5619    no more pending elements to output now.
5620
5621    If ALL is 1, we output space as necessary so that
5622    we can output all the pending elements.  */
5623
5624 static void
5625 output_pending_init_elements (int all)
5626 {
5627   struct init_node *elt = constructor_pending_elts;
5628   tree next;
5629
5630  retry:
5631
5632   /* Look through the whole pending tree.
5633      If we find an element that should be output now,
5634      output it.  Otherwise, set NEXT to the element
5635      that comes first among those still pending.  */
5636
5637   next = 0;
5638   while (elt)
5639     {
5640       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5641         {
5642           if (tree_int_cst_equal (elt->purpose,
5643                                   constructor_unfilled_index))
5644             output_init_element (elt->value, true,
5645                                  TREE_TYPE (constructor_type),
5646                                  constructor_unfilled_index, 0);
5647           else if (tree_int_cst_lt (constructor_unfilled_index,
5648                                     elt->purpose))
5649             {
5650               /* Advance to the next smaller node.  */
5651               if (elt->left)
5652                 elt = elt->left;
5653               else
5654                 {
5655                   /* We have reached the smallest node bigger than the
5656                      current unfilled index.  Fill the space first.  */
5657                   next = elt->purpose;
5658                   break;
5659                 }
5660             }
5661           else
5662             {
5663               /* Advance to the next bigger node.  */
5664               if (elt->right)
5665                 elt = elt->right;
5666               else
5667                 {
5668                   /* We have reached the biggest node in a subtree.  Find
5669                      the parent of it, which is the next bigger node.  */
5670                   while (elt->parent && elt->parent->right == elt)
5671                     elt = elt->parent;
5672                   elt = elt->parent;
5673                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5674                                               elt->purpose))
5675                     {
5676                       next = elt->purpose;
5677                       break;
5678                     }
5679                 }
5680             }
5681         }
5682       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5683                || TREE_CODE (constructor_type) == UNION_TYPE)
5684         {
5685           tree ctor_unfilled_bitpos, elt_bitpos;
5686
5687           /* If the current record is complete we are done.  */
5688           if (constructor_unfilled_fields == 0)
5689             break;
5690
5691           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5692           elt_bitpos = bit_position (elt->purpose);
5693           /* We can't compare fields here because there might be empty
5694              fields in between.  */
5695           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5696             {
5697               constructor_unfilled_fields = elt->purpose;
5698               output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
5699                                    elt->purpose, 0);
5700             }
5701           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5702             {
5703               /* Advance to the next smaller node.  */
5704               if (elt->left)
5705                 elt = elt->left;
5706               else
5707                 {
5708                   /* We have reached the smallest node bigger than the
5709                      current unfilled field.  Fill the space first.  */
5710                   next = elt->purpose;
5711                   break;
5712                 }
5713             }
5714           else
5715             {
5716               /* Advance to the next bigger node.  */
5717               if (elt->right)
5718                 elt = elt->right;
5719               else
5720                 {
5721                   /* We have reached the biggest node in a subtree.  Find
5722                      the parent of it, which is the next bigger node.  */
5723                   while (elt->parent && elt->parent->right == elt)
5724                     elt = elt->parent;
5725                   elt = elt->parent;
5726                   if (elt
5727                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
5728                                            bit_position (elt->purpose))))
5729                     {
5730                       next = elt->purpose;
5731                       break;
5732                     }
5733                 }
5734             }
5735         }
5736     }
5737
5738   /* Ordinarily return, but not if we want to output all
5739      and there are elements left.  */
5740   if (! (all && next != 0))
5741     return;
5742
5743   /* If it's not incremental, just skip over the gap, so that after
5744      jumping to retry we will output the next successive element.  */
5745   if (TREE_CODE (constructor_type) == RECORD_TYPE
5746       || TREE_CODE (constructor_type) == UNION_TYPE)
5747     constructor_unfilled_fields = next;
5748   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5749     constructor_unfilled_index = next;
5750
5751   /* ELT now points to the node in the pending tree with the next
5752      initializer to output.  */
5753   goto retry;
5754 }
5755 \f
5756 /* Add one non-braced element to the current constructor level.
5757    This adjusts the current position within the constructor's type.
5758    This may also start or terminate implicit levels
5759    to handle a partly-braced initializer.
5760
5761    Once this has found the correct level for the new element,
5762    it calls output_init_element.  */
5763
5764 void
5765 process_init_element (struct c_expr value)
5766 {
5767   tree orig_value = value.value;
5768   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
5769   bool strict_string = value.original_code == STRING_CST;
5770
5771   designator_depth = 0;
5772   designator_errorneous = 0;
5773
5774   /* Handle superfluous braces around string cst as in
5775      char x[] = {"foo"}; */
5776   if (string_flag
5777       && constructor_type
5778       && TREE_CODE (constructor_type) == ARRAY_TYPE
5779       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
5780       && integer_zerop (constructor_unfilled_index))
5781     {
5782       if (constructor_stack->replacement_value.value)
5783         error_init ("excess elements in char array initializer");
5784       constructor_stack->replacement_value = value;
5785       return;
5786     }
5787
5788   if (constructor_stack->replacement_value.value != 0)
5789     {
5790       error_init ("excess elements in struct initializer");
5791       return;
5792     }
5793
5794   /* Ignore elements of a brace group if it is entirely superfluous
5795      and has already been diagnosed.  */
5796   if (constructor_type == 0)
5797     return;
5798
5799   /* If we've exhausted any levels that didn't have braces,
5800      pop them now.  */
5801   while (constructor_stack->implicit)
5802     {
5803       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5804            || TREE_CODE (constructor_type) == UNION_TYPE)
5805           && constructor_fields == 0)
5806         process_init_element (pop_init_level (1));
5807       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5808                && (constructor_max_index == 0
5809                    || tree_int_cst_lt (constructor_max_index,
5810                                        constructor_index)))
5811         process_init_element (pop_init_level (1));
5812       else
5813         break;
5814     }
5815
5816   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
5817   if (constructor_range_stack)
5818     {
5819       /* If value is a compound literal and we'll be just using its
5820          content, don't put it into a SAVE_EXPR.  */
5821       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
5822           || !require_constant_value
5823           || flag_isoc99)
5824         value.value = save_expr (value.value);
5825     }
5826
5827   while (1)
5828     {
5829       if (TREE_CODE (constructor_type) == RECORD_TYPE)
5830         {
5831           tree fieldtype;
5832           enum tree_code fieldcode;
5833
5834           if (constructor_fields == 0)
5835             {
5836               pedwarn_init ("excess elements in struct initializer");
5837               break;
5838             }
5839
5840           fieldtype = TREE_TYPE (constructor_fields);
5841           if (fieldtype != error_mark_node)
5842             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5843           fieldcode = TREE_CODE (fieldtype);
5844
5845           /* Error for non-static initialization of a flexible array member.  */
5846           if (fieldcode == ARRAY_TYPE
5847               && !require_constant_value
5848               && TYPE_SIZE (fieldtype) == NULL_TREE
5849               && TREE_CHAIN (constructor_fields) == NULL_TREE)
5850             {
5851               error_init ("non-static initialization of a flexible array member");
5852               break;
5853             }
5854
5855           /* Accept a string constant to initialize a subarray.  */
5856           if (value.value != 0
5857               && fieldcode == ARRAY_TYPE
5858               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
5859               && string_flag)
5860             value.value = orig_value;
5861           /* Otherwise, if we have come to a subaggregate,
5862              and we don't have an element of its type, push into it.  */
5863           else if (value.value != 0 && !constructor_no_implicit
5864                    && value.value != error_mark_node
5865                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
5866                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5867                        || fieldcode == UNION_TYPE))
5868             {
5869               push_init_level (1);
5870               continue;
5871             }
5872
5873           if (value.value)
5874             {
5875               push_member_name (constructor_fields);
5876               output_init_element (value.value, strict_string,
5877                                    fieldtype, constructor_fields, 1);
5878               RESTORE_SPELLING_DEPTH (constructor_depth);
5879             }
5880           else
5881             /* Do the bookkeeping for an element that was
5882                directly output as a constructor.  */
5883             {
5884               /* For a record, keep track of end position of last field.  */
5885               if (DECL_SIZE (constructor_fields))
5886                 constructor_bit_index
5887                   = size_binop (PLUS_EXPR,
5888                                 bit_position (constructor_fields),
5889                                 DECL_SIZE (constructor_fields));
5890
5891               /* If the current field was the first one not yet written out,
5892                  it isn't now, so update.  */
5893               if (constructor_unfilled_fields == constructor_fields)
5894                 {
5895                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5896                   /* Skip any nameless bit fields.  */
5897                   while (constructor_unfilled_fields != 0
5898                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5899                          && DECL_NAME (constructor_unfilled_fields) == 0)
5900                     constructor_unfilled_fields =
5901                       TREE_CHAIN (constructor_unfilled_fields);
5902                 }
5903             }
5904
5905           constructor_fields = TREE_CHAIN (constructor_fields);
5906           /* Skip any nameless bit fields at the beginning.  */
5907           while (constructor_fields != 0
5908                  && DECL_C_BIT_FIELD (constructor_fields)
5909                  && DECL_NAME (constructor_fields) == 0)
5910             constructor_fields = TREE_CHAIN (constructor_fields);
5911         }
5912       else if (TREE_CODE (constructor_type) == UNION_TYPE)
5913         {
5914           tree fieldtype;
5915           enum tree_code fieldcode;
5916
5917           if (constructor_fields == 0)
5918             {
5919               pedwarn_init ("excess elements in union initializer");
5920               break;
5921             }
5922
5923           fieldtype = TREE_TYPE (constructor_fields);
5924           if (fieldtype != error_mark_node)
5925             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5926           fieldcode = TREE_CODE (fieldtype);
5927
5928           /* Warn that traditional C rejects initialization of unions.
5929              We skip the warning if the value is zero.  This is done
5930              under the assumption that the zero initializer in user
5931              code appears conditioned on e.g. __STDC__ to avoid
5932              "missing initializer" warnings and relies on default
5933              initialization to zero in the traditional C case.
5934              We also skip the warning if the initializer is designated,
5935              again on the assumption that this must be conditional on
5936              __STDC__ anyway (and we've already complained about the
5937              member-designator already).  */
5938           if (warn_traditional && !in_system_header && !constructor_designated
5939               && !(value.value && (integer_zerop (value.value)
5940                                    || real_zerop (value.value))))
5941             warning ("traditional C rejects initialization of unions");
5942
5943           /* Accept a string constant to initialize a subarray.  */
5944           if (value.value != 0
5945               && fieldcode == ARRAY_TYPE
5946               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
5947               && string_flag)
5948             value.value = orig_value;
5949           /* Otherwise, if we have come to a subaggregate,
5950              and we don't have an element of its type, push into it.  */
5951           else if (value.value != 0 && !constructor_no_implicit
5952                    && value.value != error_mark_node
5953                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
5954                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5955                        || fieldcode == UNION_TYPE))
5956             {
5957               push_init_level (1);
5958               continue;
5959             }
5960
5961           if (value.value)
5962             {
5963               push_member_name (constructor_fields);
5964               output_init_element (value.value, strict_string,
5965                                    fieldtype, constructor_fields, 1);
5966               RESTORE_SPELLING_DEPTH (constructor_depth);
5967             }
5968           else
5969             /* Do the bookkeeping for an element that was
5970                directly output as a constructor.  */
5971             {
5972               constructor_bit_index = DECL_SIZE (constructor_fields);
5973               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5974             }
5975
5976           constructor_fields = 0;
5977         }
5978       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5979         {
5980           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5981           enum tree_code eltcode = TREE_CODE (elttype);
5982
5983           /* Accept a string constant to initialize a subarray.  */
5984           if (value.value != 0
5985               && eltcode == ARRAY_TYPE
5986               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
5987               && string_flag)
5988             value.value = orig_value;
5989           /* Otherwise, if we have come to a subaggregate,
5990              and we don't have an element of its type, push into it.  */
5991           else if (value.value != 0 && !constructor_no_implicit
5992                    && value.value != error_mark_node
5993                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
5994                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
5995                        || eltcode == UNION_TYPE))
5996             {
5997               push_init_level (1);
5998               continue;
5999             }
6000
6001           if (constructor_max_index != 0
6002               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6003                   || integer_all_onesp (constructor_max_index)))
6004             {
6005               pedwarn_init ("excess elements in array initializer");
6006               break;
6007             }
6008
6009           /* Now output the actual element.  */
6010           if (value.value)
6011             {
6012               push_array_bounds (tree_low_cst (constructor_index, 0));
6013               output_init_element (value.value, strict_string,
6014                                    elttype, constructor_index, 1);
6015               RESTORE_SPELLING_DEPTH (constructor_depth);
6016             }
6017
6018           constructor_index
6019             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6020
6021           if (!value.value)
6022             /* If we are doing the bookkeeping for an element that was
6023                directly output as a constructor, we must update
6024                constructor_unfilled_index.  */
6025             constructor_unfilled_index = constructor_index;
6026         }
6027       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6028         {
6029           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6030
6031          /* Do a basic check of initializer size.  Note that vectors
6032             always have a fixed size derived from their type.  */
6033           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6034             {
6035               pedwarn_init ("excess elements in vector initializer");
6036               break;
6037             }
6038
6039           /* Now output the actual element.  */
6040           if (value.value)
6041             output_init_element (value.value, strict_string,
6042                                  elttype, constructor_index, 1);
6043
6044           constructor_index
6045             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6046
6047           if (!value.value)
6048             /* If we are doing the bookkeeping for an element that was
6049                directly output as a constructor, we must update
6050                constructor_unfilled_index.  */
6051             constructor_unfilled_index = constructor_index;
6052         }
6053
6054       /* Handle the sole element allowed in a braced initializer
6055          for a scalar variable.  */
6056       else if (constructor_fields == 0)
6057         {
6058           pedwarn_init ("excess elements in scalar initializer");
6059           break;
6060         }
6061       else
6062         {
6063           if (value.value)
6064             output_init_element (value.value, strict_string,
6065                                  constructor_type, NULL_TREE, 1);
6066           constructor_fields = 0;
6067         }
6068
6069       /* Handle range initializers either at this level or anywhere higher
6070          in the designator stack.  */
6071       if (constructor_range_stack)
6072         {
6073           struct constructor_range_stack *p, *range_stack;
6074           int finish = 0;
6075
6076           range_stack = constructor_range_stack;
6077           constructor_range_stack = 0;
6078           while (constructor_stack != range_stack->stack)
6079             {
6080               if (!constructor_stack->implicit)
6081                 abort ();
6082               process_init_element (pop_init_level (1));
6083             }
6084           for (p = range_stack;
6085                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6086                p = p->prev)
6087             {
6088               if (!constructor_stack->implicit)
6089                 abort ();
6090               process_init_element (pop_init_level (1));
6091             }
6092
6093           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6094           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6095             finish = 1;
6096
6097           while (1)
6098             {
6099               constructor_index = p->index;
6100               constructor_fields = p->fields;
6101               if (finish && p->range_end && p->index == p->range_start)
6102                 {
6103                   finish = 0;
6104                   p->prev = 0;
6105                 }
6106               p = p->next;
6107               if (!p)
6108                 break;
6109               push_init_level (2);
6110               p->stack = constructor_stack;
6111               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6112                 p->index = p->range_start;
6113             }
6114
6115           if (!finish)
6116             constructor_range_stack = range_stack;
6117           continue;
6118         }
6119
6120       break;
6121     }
6122
6123   constructor_range_stack = 0;
6124 }
6125 \f
6126 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6127    (guaranteed to be 'volatile' or null) and ARGS (represented using
6128    an ASM_EXPR node).  */
6129 tree
6130 build_asm_stmt (tree cv_qualifier, tree args)
6131 {
6132   if (!ASM_VOLATILE_P (args) && cv_qualifier)
6133     ASM_VOLATILE_P (args) = 1;
6134   return add_stmt (args);
6135 }
6136
6137 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6138    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
6139    SIMPLE indicates whether there was anything at all after the
6140    string in the asm expression -- asm("blah") and asm("blah" : )
6141    are subtly different.  We use a ASM_EXPR node to represent this.  */
6142 tree
6143 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6144                 bool simple)
6145 {
6146   tree tail;
6147   tree args;
6148   int i;
6149   const char *constraint;
6150   bool allows_mem, allows_reg, is_inout;
6151   int ninputs;
6152   int noutputs;
6153
6154   ninputs = list_length (inputs);
6155   noutputs = list_length (outputs);
6156
6157   /* Remove output conversions that change the type but not the mode.  */
6158   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
6159     {
6160       tree output = TREE_VALUE (tail);
6161       STRIP_NOPS (output);
6162       TREE_VALUE (tail) = output;
6163       lvalue_or_else (output, "invalid lvalue in asm statement");
6164
6165       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6166
6167       if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
6168                                     &allows_mem, &allows_reg, &is_inout))
6169         {
6170           /* By marking this operand as erroneous, we will not try
6171           to process this operand again in expand_asm_operands.  */
6172           TREE_VALUE (tail) = error_mark_node;
6173           continue;
6174         }
6175
6176       /* If the operand is a DECL that is going to end up in
6177         memory, assume it is addressable.  This is a bit more
6178         conservative than it would ideally be; the exact test is
6179         buried deep in expand_asm_operands and depends on the
6180         DECL_RTL for the OPERAND -- which we don't have at this
6181         point.  */
6182       if (!allows_reg && DECL_P (output))
6183         c_mark_addressable (output);
6184     }
6185
6186   /* Perform default conversions on array and function inputs.
6187      Don't do this for other types as it would screw up operands
6188      expected to be in memory.  */
6189   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6190     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6191
6192   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
6193
6194   /* Simple asm statements are treated as volatile.  */
6195   if (simple)
6196     {
6197       ASM_VOLATILE_P (args) = 1;
6198       ASM_INPUT_P (args) = 1;
6199     }
6200   return args;
6201 }
6202 \f
6203 /* Generate a goto statement to LABEL.  */
6204
6205 tree
6206 c_finish_goto_label (tree label)
6207 {
6208   tree decl = lookup_label (label);
6209   if (!decl)
6210     return NULL_TREE;
6211
6212   TREE_USED (decl) = 1;
6213   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
6214 }
6215
6216 /* Generate a computed goto statement to EXPR.  */
6217
6218 tree
6219 c_finish_goto_ptr (tree expr)
6220 {
6221   if (pedantic)
6222     pedwarn ("ISO C forbids `goto *expr;'");
6223   expr = convert (ptr_type_node, expr);
6224   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
6225 }
6226
6227 /* Generate a C `return' statement.  RETVAL is the expression for what
6228    to return, or a null pointer for `return;' with no value.  */
6229
6230 tree
6231 c_finish_return (tree retval)
6232 {
6233   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6234
6235   if (TREE_THIS_VOLATILE (current_function_decl))
6236     warning ("function declared `noreturn' has a `return' statement");
6237
6238   if (!retval)
6239     {
6240       current_function_returns_null = 1;
6241       if ((warn_return_type || flag_isoc99)
6242           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6243         pedwarn_c99 ("`return' with no value, in function returning non-void");
6244     }
6245   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6246     {
6247       current_function_returns_null = 1;
6248       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6249         pedwarn ("`return' with a value, in function returning void");
6250     }
6251   else
6252     {
6253       tree t = convert_for_assignment (valtype, retval, _("return"),
6254                                        NULL_TREE, NULL_TREE, 0);
6255       tree res = DECL_RESULT (current_function_decl);
6256       tree inner;
6257
6258       current_function_returns_value = 1;
6259       if (t == error_mark_node)
6260         return NULL_TREE;
6261
6262       inner = t = convert (TREE_TYPE (res), t);
6263
6264       /* Strip any conversions, additions, and subtractions, and see if
6265          we are returning the address of a local variable.  Warn if so.  */
6266       while (1)
6267         {
6268           switch (TREE_CODE (inner))
6269             {
6270             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6271             case PLUS_EXPR:
6272               inner = TREE_OPERAND (inner, 0);
6273               continue;
6274
6275             case MINUS_EXPR:
6276               /* If the second operand of the MINUS_EXPR has a pointer
6277                  type (or is converted from it), this may be valid, so
6278                  don't give a warning.  */
6279               {
6280                 tree op1 = TREE_OPERAND (inner, 1);
6281
6282                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6283                        && (TREE_CODE (op1) == NOP_EXPR
6284                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6285                            || TREE_CODE (op1) == CONVERT_EXPR))
6286                   op1 = TREE_OPERAND (op1, 0);
6287
6288                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6289                   break;
6290
6291                 inner = TREE_OPERAND (inner, 0);
6292                 continue;
6293               }
6294
6295             case ADDR_EXPR:
6296               inner = TREE_OPERAND (inner, 0);
6297
6298               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r'
6299                      && TREE_CODE (inner) != INDIRECT_REF)
6300                 inner = TREE_OPERAND (inner, 0);
6301
6302               if (DECL_P (inner)
6303                   && ! DECL_EXTERNAL (inner)
6304                   && ! TREE_STATIC (inner)
6305                   && DECL_CONTEXT (inner) == current_function_decl)
6306                 warning ("function returns address of local variable");
6307               break;
6308
6309             default:
6310               break;
6311             }
6312
6313           break;
6314         }
6315
6316       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
6317     }
6318
6319   return add_stmt (build_stmt (RETURN_EXPR, retval));
6320 }
6321 \f
6322 struct c_switch {
6323   /* The SWITCH_STMT being built.  */
6324   tree switch_stmt;
6325
6326   /* The original type of the testing expression, ie. before the
6327      default conversion is applied.  */
6328   tree orig_type;
6329
6330   /* A splay-tree mapping the low element of a case range to the high
6331      element, or NULL_TREE if there is no high element.  Used to
6332      determine whether or not a new case label duplicates an old case
6333      label.  We need a tree, rather than simply a hash table, because
6334      of the GNU case range extension.  */
6335   splay_tree cases;
6336
6337   /* The next node on the stack.  */
6338   struct c_switch *next;
6339 };
6340
6341 /* A stack of the currently active switch statements.  The innermost
6342    switch statement is on the top of the stack.  There is no need to
6343    mark the stack for garbage collection because it is only active
6344    during the processing of the body of a function, and we never
6345    collect at that point.  */
6346
6347 struct c_switch *c_switch_stack;
6348
6349 /* Start a C switch statement, testing expression EXP.  Return the new
6350    SWITCH_STMT.  */
6351
6352 tree
6353 c_start_case (tree exp)
6354 {
6355   enum tree_code code;
6356   tree type, orig_type = error_mark_node;
6357   struct c_switch *cs;
6358
6359   if (exp != error_mark_node)
6360     {
6361       code = TREE_CODE (TREE_TYPE (exp));
6362       orig_type = TREE_TYPE (exp);
6363
6364       if (! INTEGRAL_TYPE_P (orig_type)
6365           && code != ERROR_MARK)
6366         {
6367           error ("switch quantity not an integer");
6368           exp = integer_zero_node;
6369         }
6370       else
6371         {
6372           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6373
6374           if (warn_traditional && !in_system_header
6375               && (type == long_integer_type_node
6376                   || type == long_unsigned_type_node))
6377             warning ("`long' switch expression not converted to `int' in ISO C");
6378
6379           exp = default_conversion (exp);
6380           type = TREE_TYPE (exp);
6381         }
6382     }
6383
6384   /* Add this new SWITCH_STMT to the stack.  */
6385   cs = XNEW (struct c_switch);
6386   cs->switch_stmt = build_stmt ((enum tree_code) SWITCH_STMT, exp, NULL_TREE,
6387                                 orig_type);
6388   cs->orig_type = orig_type;
6389   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6390   cs->next = c_switch_stack;
6391   c_switch_stack = cs;
6392
6393   return add_stmt (cs->switch_stmt);
6394 }
6395
6396 /* Process a case label.  */
6397
6398 tree
6399 do_case (tree low_value, tree high_value)
6400 {
6401   tree label = NULL_TREE;
6402
6403   if (c_switch_stack)
6404     {
6405       label = c_add_case_label (c_switch_stack->cases,
6406                                 SWITCH_COND (c_switch_stack->switch_stmt),
6407                                 c_switch_stack->orig_type,
6408                                 low_value, high_value);
6409       if (label == error_mark_node)
6410         label = NULL_TREE;
6411     }
6412   else if (low_value)
6413     error ("case label not within a switch statement");
6414   else
6415     error ("`default' label not within a switch statement");
6416
6417   return label;
6418 }
6419
6420 /* Finish the switch statement.  */
6421
6422 void
6423 c_finish_case (tree body)
6424 {
6425   struct c_switch *cs = c_switch_stack;
6426
6427   SWITCH_BODY (cs->switch_stmt) = body;
6428
6429   /* Emit warnings as needed.  */
6430   c_do_switch_warnings (cs->cases, cs->switch_stmt);
6431
6432   /* Pop the stack.  */
6433   c_switch_stack = cs->next;
6434   splay_tree_delete (cs->cases);
6435   XDELETE (cs);
6436 }
6437 \f
6438 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
6439    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6440    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
6441    statement, and was not surrounded with parenthesis.  */
6442
6443 void
6444 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
6445                   tree else_block, bool nested_if)
6446 {
6447   tree stmt;
6448
6449   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
6450   if (warn_parentheses && nested_if && else_block == NULL)
6451     {
6452       tree inner_if = then_block;
6453
6454       /* We know from the grammar productions that there is an IF nested
6455          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
6456          it might not be exactly THEN_BLOCK, but should be the last
6457          non-container statement within.  */
6458       while (1)
6459         switch (TREE_CODE (inner_if))
6460           {
6461           case COND_EXPR:
6462             goto found;
6463           case BIND_EXPR:
6464             inner_if = BIND_EXPR_BODY (inner_if);
6465             break;
6466           case STATEMENT_LIST:
6467             inner_if = expr_last (then_block);
6468             break;
6469           case TRY_FINALLY_EXPR:
6470           case TRY_CATCH_EXPR:
6471             inner_if = TREE_OPERAND (inner_if, 0);
6472             break;
6473           default:
6474             abort ();
6475           }
6476     found:
6477
6478       if (COND_EXPR_ELSE (inner_if))
6479          warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
6480                   &if_locus);
6481     }
6482
6483   /* Diagnose ";" via the special empty statement node that we create.  */
6484   if (extra_warnings)
6485     {
6486       if (TREE_CODE (then_block) == NOP_EXPR && !TREE_TYPE (then_block))
6487         {
6488           if (!else_block)
6489             warning ("%Hempty body in an if-statement",
6490                      EXPR_LOCUS (then_block));
6491           then_block = alloc_stmt_list ();
6492         }
6493       if (else_block
6494           && TREE_CODE (else_block) == NOP_EXPR
6495           && !TREE_TYPE (else_block))
6496         {
6497           warning ("%Hempty body in an else-statement",
6498                    EXPR_LOCUS (else_block));
6499           else_block = alloc_stmt_list ();
6500         }
6501     }
6502
6503   stmt = build3 (COND_EXPR, NULL_TREE, cond, then_block, else_block);
6504   SET_EXPR_LOCATION (stmt, if_locus);
6505   add_stmt (stmt);
6506 }
6507
6508 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
6509    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
6510    is false for DO loops.  INCR is the FOR increment expression.  BODY is
6511    the statement controlled by the loop.  BLAB is the break label.  CLAB is
6512    the continue label.  Everything is allowed to be NULL.  */
6513
6514 void
6515 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
6516                tree blab, tree clab, bool cond_is_first)
6517 {
6518   tree entry = NULL, exit = NULL, t;
6519
6520   /* Detect do { ... } while (0) and don't generate loop construct.  */
6521   if (cond && !cond_is_first && integer_zerop (cond))
6522     cond = NULL;
6523   if (cond_is_first || cond)
6524     {
6525       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6526
6527       /* If we have an exit condition, then we build an IF with gotos either
6528          out of the loop, or to the top of it.  If there's no exit condition,
6529          then we just build a jump back to the top.  */
6530       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
6531
6532       if (cond)
6533         {
6534           /* Canonicalize the loop condition to the end.  This means
6535              generating a branch to the loop condition.  Reuse the
6536              continue label, if possible.  */
6537           if (cond_is_first)
6538             {
6539               if (incr || !clab)
6540                 {
6541                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6542                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
6543                 }
6544               else
6545                 t = build1 (GOTO_EXPR, void_type_node, clab);
6546               SET_EXPR_LOCATION (t, start_locus);
6547               add_stmt (t);
6548             }
6549
6550           t = build_and_jump (&blab);
6551           exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
6552           exit = fold (exit);
6553           if (cond_is_first)
6554             SET_EXPR_LOCATION (exit, start_locus);
6555           else
6556             SET_EXPR_LOCATION (exit, input_location);
6557         }
6558
6559       add_stmt (top);
6560     }
6561
6562   if (body)
6563     add_stmt (body);
6564   if (clab)
6565     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
6566   if (incr)
6567     add_stmt (incr);
6568   if (entry)
6569     add_stmt (entry);
6570   if (exit)
6571     add_stmt (exit);
6572   if (blab)
6573     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
6574 }
6575
6576 tree
6577 c_finish_bc_stmt (tree *label_p, bool is_break)
6578 {
6579   tree label = *label_p;
6580
6581   if (!label)
6582     *label_p = label = create_artificial_label ();
6583   else if (TREE_CODE (label) != LABEL_DECL)
6584     {
6585       if (is_break)
6586         error ("break statement not within loop or switch");
6587       else
6588         error ("continue statement not within a loop");
6589       return NULL_TREE;
6590     }
6591
6592   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
6593 }
6594
6595 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
6596
6597 static void
6598 emit_side_effect_warnings (tree expr)
6599 {
6600   if (expr == error_mark_node)
6601     ;
6602   else if (!TREE_SIDE_EFFECTS (expr))
6603     {
6604       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
6605         warning ("%Hstatement with no effect",
6606                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
6607     }
6608   else if (warn_unused_value)
6609     warn_if_unused_value (expr, input_location);
6610 }
6611
6612 /* Process an expression as if it were a complete statement.  Emit
6613    diagnostics, but do not call ADD_STMT.  */
6614
6615 tree
6616 c_process_expr_stmt (tree expr)
6617 {
6618   if (!expr)
6619     return NULL_TREE;
6620
6621   /* Do default conversion if safe and possibly important,
6622      in case within ({...}).  */
6623   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
6624        && (flag_isoc99 || lvalue_p (expr)))
6625       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
6626     expr = default_conversion (expr);
6627
6628   if (warn_sequence_point)
6629     verify_sequence_points (expr);
6630
6631   if (TREE_TYPE (expr) != error_mark_node
6632       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
6633       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
6634     error ("expression statement has incomplete type");
6635
6636   /* If we're not processing a statement expression, warn about unused values.
6637      Warnings for statement expressions will be emitted later, once we figure
6638      out which is the result.  */
6639   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6640       && (extra_warnings || warn_unused_value))
6641     emit_side_effect_warnings (expr);
6642
6643   /* If the expression is not of a type to which we cannot assign a line
6644      number, wrap the thing in a no-op NOP_EXPR.  */
6645   if (DECL_P (expr) || TREE_CODE_CLASS (TREE_CODE (expr)) == 'c')
6646     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
6647
6648   if (EXPR_P (expr))
6649     SET_EXPR_LOCATION (expr, input_location);
6650
6651   return expr;
6652 }
6653
6654 /* Emit an expression as a statement.  */
6655
6656 tree
6657 c_finish_expr_stmt (tree expr)
6658 {
6659   if (expr)
6660     return add_stmt (c_process_expr_stmt (expr));
6661   else
6662     return NULL;
6663 }
6664
6665 /* Do the opposite and emit a statement as an expression.  To begin,
6666    create a new binding level and return it.  */
6667
6668 tree
6669 c_begin_stmt_expr (void)
6670 {
6671   tree ret;
6672
6673   /* We must force a BLOCK for this level so that, if it is not expanded
6674      later, there is a way to turn off the entire subtree of blocks that
6675      are contained in it.  */
6676   keep_next_level ();
6677   ret = c_begin_compound_stmt (true);
6678
6679   /* Mark the current statement list as belonging to a statement list.  */
6680   STATEMENT_LIST_STMT_EXPR (ret) = 1;
6681
6682   return ret;
6683 }
6684
6685 tree
6686 c_finish_stmt_expr (tree body)
6687 {
6688   tree last, type, tmp, val;
6689   tree *last_p;
6690
6691   body = c_end_compound_stmt (body, true);
6692
6693   /* Locate the last statement in BODY.  See c_end_compound_stmt
6694      about always returning a BIND_EXPR.  */
6695   last_p = &BIND_EXPR_BODY (body);
6696   last = BIND_EXPR_BODY (body);
6697
6698  continue_searching:
6699   if (TREE_CODE (last) == STATEMENT_LIST)
6700     {
6701       tree_stmt_iterator i;
6702
6703       /* This can happen with degenerate cases like ({ }).  No value.  */
6704       if (!TREE_SIDE_EFFECTS (last))
6705         return body;
6706
6707       /* If we're supposed to generate side effects warnings, process
6708          all of the statements except the last.  */
6709       if (extra_warnings || warn_unused_value)
6710         {
6711           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
6712             emit_side_effect_warnings (tsi_stmt (i));
6713         }
6714       else
6715         i = tsi_last (last);
6716       last_p = tsi_stmt_ptr (i);
6717       last = *last_p;
6718     }
6719
6720   /* If the end of the list is exception related, then the list was split
6721      by a call to push_cleanup.  Continue searching.  */
6722   if (TREE_CODE (last) == TRY_FINALLY_EXPR
6723       || TREE_CODE (last) == TRY_CATCH_EXPR)
6724     {
6725       last_p = &TREE_OPERAND (last, 0);
6726       last = *last_p;
6727       goto continue_searching;
6728     }
6729
6730   /* In the case that the BIND_EXPR is not necessary, return the
6731      expression out from inside it.  */
6732   if (last == error_mark_node
6733       || (last == BIND_EXPR_BODY (body)
6734           && BIND_EXPR_VARS (body) == NULL))
6735     return last;
6736
6737   /* Extract the type of said expression.  */
6738   type = TREE_TYPE (last);
6739
6740   /* If we're not returning a value at all, then the BIND_EXPR that
6741      we already have is a fine expression to return.  */
6742   if (!type || VOID_TYPE_P (type))
6743     return body;
6744
6745   /* Now that we've located the expression containing the value, it seems
6746      silly to make voidify_wrapper_expr repeat the process.  Create a
6747      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
6748   tmp = create_tmp_var_raw (type, NULL);
6749
6750   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
6751      tree_expr_nonnegative_p giving up immediately.  */
6752   val = last;
6753   if (TREE_CODE (val) == NOP_EXPR
6754       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
6755     val = TREE_OPERAND (val, 0);
6756
6757   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
6758   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
6759
6760   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
6761 }
6762 \f
6763 /* Begin and end compound statements.  This is as simple as pushing
6764    and popping new statement lists from the tree.  */
6765
6766 tree
6767 c_begin_compound_stmt (bool do_scope)
6768 {
6769   tree stmt = push_stmt_list ();
6770   if (do_scope)
6771     push_scope ();
6772   return stmt;
6773 }
6774
6775 tree
6776 c_end_compound_stmt (tree stmt, bool do_scope)
6777 {
6778   tree block = NULL;
6779
6780   if (do_scope)
6781     {
6782       if (c_dialect_objc ())
6783         objc_clear_super_receiver ();
6784       block = pop_scope ();
6785     }
6786
6787   stmt = pop_stmt_list (stmt);
6788   stmt = c_build_bind_expr (block, stmt);
6789
6790   /* If this compound statement is nested immediately inside a statement
6791      expression, then force a BIND_EXPR to be created.  Otherwise we'll
6792      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
6793      STATEMENT_LISTs merge, and thus we can lose track of what statement
6794      was really last.  */
6795   if (cur_stmt_list
6796       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6797       && TREE_CODE (stmt) != BIND_EXPR)
6798     {
6799       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
6800       TREE_SIDE_EFFECTS (stmt) = 1;
6801     }
6802
6803   return stmt;
6804 }
6805
6806 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
6807    when the current scope is exited.  EH_ONLY is true when this is not
6808    meant to apply to normal control flow transfer.  */
6809
6810 void
6811 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
6812 {
6813   enum tree_code code;
6814   tree stmt, list;
6815   bool stmt_expr;
6816
6817   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
6818   stmt = build_stmt (code, NULL, cleanup);
6819   add_stmt (stmt);
6820   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
6821   list = push_stmt_list ();
6822   TREE_OPERAND (stmt, 0) = list;
6823   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
6824 }
6825 \f
6826 /* Build a binary-operation expression without default conversions.
6827    CODE is the kind of expression to build.
6828    This function differs from `build' in several ways:
6829    the data type of the result is computed and recorded in it,
6830    warnings are generated if arg data types are invalid,
6831    special handling for addition and subtraction of pointers is known,
6832    and some optimization is done (operations on narrow ints
6833    are done in the narrower type when that gives the same result).
6834    Constant folding is also done before the result is returned.
6835
6836    Note that the operands will never have enumeral types, or function
6837    or array types, because either they will have the default conversions
6838    performed or they have both just been converted to some other type in which
6839    the arithmetic is to be done.  */
6840
6841 tree
6842 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6843                  int convert_p)
6844 {
6845   tree type0, type1;
6846   enum tree_code code0, code1;
6847   tree op0, op1;
6848
6849   /* Expression code to give to the expression when it is built.
6850      Normally this is CODE, which is what the caller asked for,
6851      but in some special cases we change it.  */
6852   enum tree_code resultcode = code;
6853
6854   /* Data type in which the computation is to be performed.
6855      In the simplest cases this is the common type of the arguments.  */
6856   tree result_type = NULL;
6857
6858   /* Nonzero means operands have already been type-converted
6859      in whatever way is necessary.
6860      Zero means they need to be converted to RESULT_TYPE.  */
6861   int converted = 0;
6862
6863   /* Nonzero means create the expression with this type, rather than
6864      RESULT_TYPE.  */
6865   tree build_type = 0;
6866
6867   /* Nonzero means after finally constructing the expression
6868      convert it to this type.  */
6869   tree final_type = 0;
6870
6871   /* Nonzero if this is an operation like MIN or MAX which can
6872      safely be computed in short if both args are promoted shorts.
6873      Also implies COMMON.
6874      -1 indicates a bitwise operation; this makes a difference
6875      in the exact conditions for when it is safe to do the operation
6876      in a narrower mode.  */
6877   int shorten = 0;
6878
6879   /* Nonzero if this is a comparison operation;
6880      if both args are promoted shorts, compare the original shorts.
6881      Also implies COMMON.  */
6882   int short_compare = 0;
6883
6884   /* Nonzero if this is a right-shift operation, which can be computed on the
6885      original short and then promoted if the operand is a promoted short.  */
6886   int short_shift = 0;
6887
6888   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
6889   int common = 0;
6890
6891   if (convert_p)
6892     {
6893       op0 = default_conversion (orig_op0);
6894       op1 = default_conversion (orig_op1);
6895     }
6896   else
6897     {
6898       op0 = orig_op0;
6899       op1 = orig_op1;
6900     }
6901
6902   type0 = TREE_TYPE (op0);
6903   type1 = TREE_TYPE (op1);
6904
6905   /* The expression codes of the data types of the arguments tell us
6906      whether the arguments are integers, floating, pointers, etc.  */
6907   code0 = TREE_CODE (type0);
6908   code1 = TREE_CODE (type1);
6909
6910   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
6911   STRIP_TYPE_NOPS (op0);
6912   STRIP_TYPE_NOPS (op1);
6913
6914   /* If an error was already reported for one of the arguments,
6915      avoid reporting another error.  */
6916
6917   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6918     return error_mark_node;
6919
6920   switch (code)
6921     {
6922     case PLUS_EXPR:
6923       /* Handle the pointer + int case.  */
6924       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6925         return pointer_int_sum (PLUS_EXPR, op0, op1);
6926       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
6927         return pointer_int_sum (PLUS_EXPR, op1, op0);
6928       else
6929         common = 1;
6930       break;
6931
6932     case MINUS_EXPR:
6933       /* Subtraction of two similar pointers.
6934          We must subtract them as integers, then divide by object size.  */
6935       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
6936           && comp_target_types (type0, type1, 1))
6937         return pointer_diff (op0, op1);
6938       /* Handle pointer minus int.  Just like pointer plus int.  */
6939       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6940         return pointer_int_sum (MINUS_EXPR, op0, op1);
6941       else
6942         common = 1;
6943       break;
6944
6945     case MULT_EXPR:
6946       common = 1;
6947       break;
6948
6949     case TRUNC_DIV_EXPR:
6950     case CEIL_DIV_EXPR:
6951     case FLOOR_DIV_EXPR:
6952     case ROUND_DIV_EXPR:
6953     case EXACT_DIV_EXPR:
6954       /* Floating point division by zero is a legitimate way to obtain
6955          infinities and NaNs.  */
6956       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6957         warning ("division by zero");
6958
6959       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6960            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6961           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6962               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
6963         {
6964           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6965             code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
6966           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
6967             code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
6968
6969           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
6970             resultcode = RDIV_EXPR;
6971           else
6972             /* Although it would be tempting to shorten always here, that
6973                loses on some targets, since the modulo instruction is
6974                undefined if the quotient can't be represented in the
6975                computation mode.  We shorten only if unsigned or if
6976                dividing by something we know != -1.  */
6977             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
6978                        || (TREE_CODE (op1) == INTEGER_CST
6979                            && ! integer_all_onesp (op1)));
6980           common = 1;
6981         }
6982       break;
6983
6984     case BIT_AND_EXPR:
6985     case BIT_IOR_EXPR:
6986     case BIT_XOR_EXPR:
6987       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6988         shorten = -1;
6989       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
6990         common = 1;
6991       break;
6992
6993     case TRUNC_MOD_EXPR:
6994     case FLOOR_MOD_EXPR:
6995       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6996         warning ("division by zero");
6997
6998       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6999         {
7000           /* Although it would be tempting to shorten always here, that loses
7001              on some targets, since the modulo instruction is undefined if the
7002              quotient can't be represented in the computation mode.  We shorten
7003              only if unsigned or if dividing by something we know != -1.  */
7004           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7005                      || (TREE_CODE (op1) == INTEGER_CST
7006                          && ! integer_all_onesp (op1)));
7007           common = 1;
7008         }
7009       break;
7010
7011     case TRUTH_ANDIF_EXPR:
7012     case TRUTH_ORIF_EXPR:
7013     case TRUTH_AND_EXPR:
7014     case TRUTH_OR_EXPR:
7015     case TRUTH_XOR_EXPR:
7016       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
7017            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
7018           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
7019               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
7020         {
7021           /* Result of these operations is always an int,
7022              but that does not mean the operands should be
7023              converted to ints!  */
7024           result_type = integer_type_node;
7025           op0 = lang_hooks.truthvalue_conversion (op0);
7026           op1 = lang_hooks.truthvalue_conversion (op1);
7027           converted = 1;
7028         }
7029       break;
7030
7031       /* Shift operations: result has same type as first operand;
7032          always convert second operand to int.
7033          Also set SHORT_SHIFT if shifting rightward.  */
7034
7035     case RSHIFT_EXPR:
7036       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7037         {
7038           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7039             {
7040               if (tree_int_cst_sgn (op1) < 0)
7041                 warning ("right shift count is negative");
7042               else
7043                 {
7044                   if (! integer_zerop (op1))
7045                     short_shift = 1;
7046
7047                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7048                     warning ("right shift count >= width of type");
7049                 }
7050             }
7051
7052           /* Use the type of the value to be shifted.  */
7053           result_type = type0;
7054           /* Convert the shift-count to an integer, regardless of size
7055              of value being shifted.  */
7056           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7057             op1 = convert (integer_type_node, op1);
7058           /* Avoid converting op1 to result_type later.  */
7059           converted = 1;
7060         }
7061       break;
7062
7063     case LSHIFT_EXPR:
7064       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7065         {
7066           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7067             {
7068               if (tree_int_cst_sgn (op1) < 0)
7069                 warning ("left shift count is negative");
7070
7071               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7072                 warning ("left shift count >= width of type");
7073             }
7074
7075           /* Use the type of the value to be shifted.  */
7076           result_type = type0;
7077           /* Convert the shift-count to an integer, regardless of size
7078              of value being shifted.  */
7079           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7080             op1 = convert (integer_type_node, op1);
7081           /* Avoid converting op1 to result_type later.  */
7082           converted = 1;
7083         }
7084       break;
7085
7086     case RROTATE_EXPR:
7087     case LROTATE_EXPR:
7088       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7089         {
7090           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7091             {
7092               if (tree_int_cst_sgn (op1) < 0)
7093                 warning ("shift count is negative");
7094               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7095                 warning ("shift count >= width of type");
7096             }
7097
7098           /* Use the type of the value to be shifted.  */
7099           result_type = type0;
7100           /* Convert the shift-count to an integer, regardless of size
7101              of value being shifted.  */
7102           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7103             op1 = convert (integer_type_node, op1);
7104           /* Avoid converting op1 to result_type later.  */
7105           converted = 1;
7106         }
7107       break;
7108
7109     case EQ_EXPR:
7110     case NE_EXPR:
7111       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
7112         warning ("comparing floating point with == or != is unsafe");
7113       /* Result of comparison is always int,
7114          but don't convert the args to int!  */
7115       build_type = integer_type_node;
7116       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7117            || code0 == COMPLEX_TYPE)
7118           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7119               || code1 == COMPLEX_TYPE))
7120         short_compare = 1;
7121       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7122         {
7123           tree tt0 = TREE_TYPE (type0);
7124           tree tt1 = TREE_TYPE (type1);
7125           /* Anything compares with void *.  void * compares with anything.
7126              Otherwise, the targets must be compatible
7127              and both must be object or both incomplete.  */
7128           if (comp_target_types (type0, type1, 1))
7129             result_type = common_pointer_type (type0, type1);
7130           else if (VOID_TYPE_P (tt0))
7131             {
7132               /* op0 != orig_op0 detects the case of something
7133                  whose value is 0 but which isn't a valid null ptr const.  */
7134               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
7135                   && TREE_CODE (tt1) == FUNCTION_TYPE)
7136                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
7137             }
7138           else if (VOID_TYPE_P (tt1))
7139             {
7140               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
7141                   && TREE_CODE (tt0) == FUNCTION_TYPE)
7142                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
7143             }
7144           else
7145             pedwarn ("comparison of distinct pointer types lacks a cast");
7146
7147           if (result_type == NULL_TREE)
7148             result_type = ptr_type_node;
7149         }
7150       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7151                && integer_zerop (op1))
7152         result_type = type0;
7153       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7154                && integer_zerop (op0))
7155         result_type = type1;
7156       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7157         {
7158           result_type = type0;
7159           pedwarn ("comparison between pointer and integer");
7160         }
7161       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7162         {
7163           result_type = type1;
7164           pedwarn ("comparison between pointer and integer");
7165         }
7166       break;
7167
7168     case MAX_EXPR:
7169     case MIN_EXPR:
7170       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7171           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7172         shorten = 1;
7173       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7174         {
7175           if (comp_target_types (type0, type1, 1))
7176             {
7177               result_type = common_pointer_type (type0, type1);
7178               if (pedantic
7179                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7180                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7181             }
7182           else
7183             {
7184               result_type = ptr_type_node;
7185               pedwarn ("comparison of distinct pointer types lacks a cast");
7186             }
7187         }
7188       break;
7189
7190     case LE_EXPR:
7191     case GE_EXPR:
7192     case LT_EXPR:
7193     case GT_EXPR:
7194       build_type = integer_type_node;
7195       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7196           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7197         short_compare = 1;
7198       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7199         {
7200           if (comp_target_types (type0, type1, 1))
7201             {
7202               result_type = common_pointer_type (type0, type1);
7203               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
7204                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
7205                 pedwarn ("comparison of complete and incomplete pointers");
7206               else if (pedantic
7207                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7208                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7209             }
7210           else
7211             {
7212               result_type = ptr_type_node;
7213               pedwarn ("comparison of distinct pointer types lacks a cast");
7214             }
7215         }
7216       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7217                && integer_zerop (op1))
7218         {
7219           result_type = type0;
7220           if (pedantic || extra_warnings)
7221             pedwarn ("ordered comparison of pointer with integer zero");
7222         }
7223       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7224                && integer_zerop (op0))
7225         {
7226           result_type = type1;
7227           if (pedantic)
7228             pedwarn ("ordered comparison of pointer with integer zero");
7229         }
7230       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7231         {
7232           result_type = type0;
7233           pedwarn ("comparison between pointer and integer");
7234         }
7235       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7236         {
7237           result_type = type1;
7238           pedwarn ("comparison between pointer and integer");
7239         }
7240       break;
7241
7242     case UNORDERED_EXPR:
7243     case ORDERED_EXPR:
7244     case UNLT_EXPR:
7245     case UNLE_EXPR:
7246     case UNGT_EXPR:
7247     case UNGE_EXPR:
7248     case UNEQ_EXPR:
7249     case LTGT_EXPR:
7250       build_type = integer_type_node;
7251       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
7252         {
7253           error ("unordered comparison on non-floating point argument");
7254           return error_mark_node;
7255         }
7256       common = 1;
7257       break;
7258
7259     default:
7260       break;
7261     }
7262
7263   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7264     return error_mark_node;
7265
7266   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
7267        || code0 == VECTOR_TYPE)
7268       &&
7269       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
7270        || code1 == VECTOR_TYPE))
7271     {
7272       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7273
7274       if (shorten || common || short_compare)
7275         result_type = common_type (type0, type1);
7276
7277       /* For certain operations (which identify themselves by shorten != 0)
7278          if both args were extended from the same smaller type,
7279          do the arithmetic in that type and then extend.
7280
7281          shorten !=0 and !=1 indicates a bitwise operation.
7282          For them, this optimization is safe only if
7283          both args are zero-extended or both are sign-extended.
7284          Otherwise, we might change the result.
7285          Eg, (short)-1 | (unsigned short)-1 is (int)-1
7286          but calculated in (unsigned short) it would be (unsigned short)-1.  */
7287
7288       if (shorten && none_complex)
7289         {
7290           int unsigned0, unsigned1;
7291           tree arg0 = get_narrower (op0, &unsigned0);
7292           tree arg1 = get_narrower (op1, &unsigned1);
7293           /* UNS is 1 if the operation to be done is an unsigned one.  */
7294           int uns = TYPE_UNSIGNED (result_type);
7295           tree type;
7296
7297           final_type = result_type;
7298
7299           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7300              but it *requires* conversion to FINAL_TYPE.  */
7301
7302           if ((TYPE_PRECISION (TREE_TYPE (op0))
7303                == TYPE_PRECISION (TREE_TYPE (arg0)))
7304               && TREE_TYPE (op0) != final_type)
7305             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
7306           if ((TYPE_PRECISION (TREE_TYPE (op1))
7307                == TYPE_PRECISION (TREE_TYPE (arg1)))
7308               && TREE_TYPE (op1) != final_type)
7309             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
7310
7311           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
7312
7313           /* For bitwise operations, signedness of nominal type
7314              does not matter.  Consider only how operands were extended.  */
7315           if (shorten == -1)
7316             uns = unsigned0;
7317
7318           /* Note that in all three cases below we refrain from optimizing
7319              an unsigned operation on sign-extended args.
7320              That would not be valid.  */
7321
7322           /* Both args variable: if both extended in same way
7323              from same width, do it in that width.
7324              Do it unsigned if args were zero-extended.  */
7325           if ((TYPE_PRECISION (TREE_TYPE (arg0))
7326                < TYPE_PRECISION (result_type))
7327               && (TYPE_PRECISION (TREE_TYPE (arg1))
7328                   == TYPE_PRECISION (TREE_TYPE (arg0)))
7329               && unsigned0 == unsigned1
7330               && (unsigned0 || !uns))
7331             result_type
7332               = c_common_signed_or_unsigned_type
7333               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7334           else if (TREE_CODE (arg0) == INTEGER_CST
7335                    && (unsigned1 || !uns)
7336                    && (TYPE_PRECISION (TREE_TYPE (arg1))
7337                        < TYPE_PRECISION (result_type))
7338                    && (type
7339                        = c_common_signed_or_unsigned_type (unsigned1,
7340                                                            TREE_TYPE (arg1)),
7341                        int_fits_type_p (arg0, type)))
7342             result_type = type;
7343           else if (TREE_CODE (arg1) == INTEGER_CST
7344                    && (unsigned0 || !uns)
7345                    && (TYPE_PRECISION (TREE_TYPE (arg0))
7346                        < TYPE_PRECISION (result_type))
7347                    && (type
7348                        = c_common_signed_or_unsigned_type (unsigned0,
7349                                                            TREE_TYPE (arg0)),
7350                        int_fits_type_p (arg1, type)))
7351             result_type = type;
7352         }
7353
7354       /* Shifts can be shortened if shifting right.  */
7355
7356       if (short_shift)
7357         {
7358           int unsigned_arg;
7359           tree arg0 = get_narrower (op0, &unsigned_arg);
7360
7361           final_type = result_type;
7362
7363           if (arg0 == op0 && final_type == TREE_TYPE (op0))
7364             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
7365
7366           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7367               /* We can shorten only if the shift count is less than the
7368                  number of bits in the smaller type size.  */
7369               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7370               /* We cannot drop an unsigned shift after sign-extension.  */
7371               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
7372             {
7373               /* Do an unsigned shift if the operand was zero-extended.  */
7374               result_type
7375                 = c_common_signed_or_unsigned_type (unsigned_arg,
7376                                                     TREE_TYPE (arg0));
7377               /* Convert value-to-be-shifted to that type.  */
7378               if (TREE_TYPE (op0) != result_type)
7379                 op0 = convert (result_type, op0);
7380               converted = 1;
7381             }
7382         }
7383
7384       /* Comparison operations are shortened too but differently.
7385          They identify themselves by setting short_compare = 1.  */
7386
7387       if (short_compare)
7388         {
7389           /* Don't write &op0, etc., because that would prevent op0
7390              from being kept in a register.
7391              Instead, make copies of the our local variables and
7392              pass the copies by reference, then copy them back afterward.  */
7393           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7394           enum tree_code xresultcode = resultcode;
7395           tree val
7396             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7397
7398           if (val != 0)
7399             return val;
7400
7401           op0 = xop0, op1 = xop1;
7402           converted = 1;
7403           resultcode = xresultcode;
7404
7405           if (warn_sign_compare && skip_evaluation == 0)
7406             {
7407               int op0_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op0));
7408               int op1_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op1));
7409               int unsignedp0, unsignedp1;
7410               tree primop0 = get_narrower (op0, &unsignedp0);
7411               tree primop1 = get_narrower (op1, &unsignedp1);
7412
7413               xop0 = orig_op0;
7414               xop1 = orig_op1;
7415               STRIP_TYPE_NOPS (xop0);
7416               STRIP_TYPE_NOPS (xop1);
7417
7418               /* Give warnings for comparisons between signed and unsigned
7419                  quantities that may fail.
7420
7421                  Do the checking based on the original operand trees, so that
7422                  casts will be considered, but default promotions won't be.
7423
7424                  Do not warn if the comparison is being done in a signed type,
7425                  since the signed type will only be chosen if it can represent
7426                  all the values of the unsigned type.  */
7427               if (! TYPE_UNSIGNED (result_type))
7428                 /* OK */;
7429               /* Do not warn if both operands are the same signedness.  */
7430               else if (op0_signed == op1_signed)
7431                 /* OK */;
7432               else
7433                 {
7434                   tree sop, uop;
7435
7436                   if (op0_signed)
7437                     sop = xop0, uop = xop1;
7438                   else
7439                     sop = xop1, uop = xop0;
7440
7441                   /* Do not warn if the signed quantity is an
7442                      unsuffixed integer literal (or some static
7443                      constant expression involving such literals or a
7444                      conditional expression involving such literals)
7445                      and it is non-negative.  */
7446                   if (tree_expr_nonnegative_p (sop))
7447                     /* OK */;
7448                   /* Do not warn if the comparison is an equality operation,
7449                      the unsigned quantity is an integral constant, and it
7450                      would fit in the result if the result were signed.  */
7451                   else if (TREE_CODE (uop) == INTEGER_CST
7452                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7453                            && int_fits_type_p
7454                            (uop, c_common_signed_type (result_type)))
7455                     /* OK */;
7456                   /* Do not warn if the unsigned quantity is an enumeration
7457                      constant and its maximum value would fit in the result
7458                      if the result were signed.  */
7459                   else if (TREE_CODE (uop) == INTEGER_CST
7460                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7461                            && int_fits_type_p
7462                            (TYPE_MAX_VALUE (TREE_TYPE(uop)),
7463                             c_common_signed_type (result_type)))
7464                     /* OK */;
7465                   else
7466                     warning ("comparison between signed and unsigned");
7467                 }
7468
7469               /* Warn if two unsigned values are being compared in a size
7470                  larger than their original size, and one (and only one) is the
7471                  result of a `~' operator.  This comparison will always fail.
7472
7473                  Also warn if one operand is a constant, and the constant
7474                  does not have all bits set that are set in the ~ operand
7475                  when it is extended.  */
7476
7477               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7478                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7479                 {
7480                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7481                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7482                                             &unsignedp0);
7483                   else
7484                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7485                                             &unsignedp1);
7486
7487                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7488                     {
7489                       tree primop;
7490                       HOST_WIDE_INT constant, mask;
7491                       int unsignedp, bits;
7492
7493                       if (host_integerp (primop0, 0))
7494                         {
7495                           primop = primop1;
7496                           unsignedp = unsignedp1;
7497                           constant = tree_low_cst (primop0, 0);
7498                         }
7499                       else
7500                         {
7501                           primop = primop0;
7502                           unsignedp = unsignedp0;
7503                           constant = tree_low_cst (primop1, 0);
7504                         }
7505
7506                       bits = TYPE_PRECISION (TREE_TYPE (primop));
7507                       if (bits < TYPE_PRECISION (result_type)
7508                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7509                         {
7510                           mask = (~ (HOST_WIDE_INT) 0) << bits;
7511                           if ((mask & constant) != mask)
7512                             warning ("comparison of promoted ~unsigned with constant");
7513                         }
7514                     }
7515                   else if (unsignedp0 && unsignedp1
7516                            && (TYPE_PRECISION (TREE_TYPE (primop0))
7517                                < TYPE_PRECISION (result_type))
7518                            && (TYPE_PRECISION (TREE_TYPE (primop1))
7519                                < TYPE_PRECISION (result_type)))
7520                     warning ("comparison of promoted ~unsigned with unsigned");
7521                 }
7522             }
7523         }
7524     }
7525
7526   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7527      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7528      Then the expression will be built.
7529      It will be given type FINAL_TYPE if that is nonzero;
7530      otherwise, it will be given type RESULT_TYPE.  */
7531
7532   if (!result_type)
7533     {
7534       binary_op_error (code);
7535       return error_mark_node;
7536     }
7537
7538   if (! converted)
7539     {
7540       if (TREE_TYPE (op0) != result_type)
7541         op0 = convert (result_type, op0);
7542       if (TREE_TYPE (op1) != result_type)
7543         op1 = convert (result_type, op1);
7544
7545       /* This can happen if one operand has a vector type, and the other
7546          has a different type.  */
7547       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
7548         return error_mark_node;
7549     }
7550
7551   if (build_type == NULL_TREE)
7552     build_type = result_type;
7553
7554   {
7555     tree result = build2 (resultcode, build_type, op0, op1);
7556
7557     /* Treat expressions in initializers specially as they can't trap.  */
7558     result = require_constant_value ? fold_initializer (result)
7559                                     : fold (result);
7560
7561     if (final_type != 0)
7562       result = convert (final_type, result);
7563     return result;
7564   }
7565 }