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