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 && coder == 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 (!initializer_constant_valid_p (value, endtype))
3741     return error_mark_node;
3742   else
3743     return value;
3744 }
3745 \f
3746 /* Perform appropriate conversions on the initial value of a variable,
3747    store it in the declaration DECL,
3748    and print any error messages that are appropriate.
3749    If the init is invalid, store an ERROR_MARK.  */
3750
3751 void
3752 store_init_value (tree decl, tree init)
3753 {
3754   tree value, type;
3755
3756   /* If variable's type was invalidly declared, just ignore it.  */
3757
3758   type = TREE_TYPE (decl);
3759   if (TREE_CODE (type) == ERROR_MARK)
3760     return;
3761
3762   /* Digest the specified initializer into an expression.  */
3763
3764   value = digest_init (type, init, true, TREE_STATIC (decl));
3765
3766   /* Store the expression if valid; else report error.  */
3767
3768   if (warn_traditional && !in_system_header
3769       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
3770     warning ("traditional C rejects automatic aggregate initialization");
3771
3772   DECL_INITIAL (decl) = value;
3773
3774   /* ANSI wants warnings about out-of-range constant initializers.  */
3775   STRIP_TYPE_NOPS (value);
3776   constant_expression_warning (value);
3777
3778   /* Check if we need to set array size from compound literal size.  */
3779   if (TREE_CODE (type) == ARRAY_TYPE
3780       && TYPE_DOMAIN (type) == 0
3781       && value != error_mark_node)
3782     {
3783       tree inside_init = init;
3784
3785       if (TREE_CODE (init) == NON_LVALUE_EXPR)
3786         inside_init = TREE_OPERAND (init, 0);
3787       inside_init = fold (inside_init);
3788
3789       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3790         {
3791           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3792
3793           if (TYPE_DOMAIN (TREE_TYPE (decl)))
3794             {
3795               /* For int foo[] = (int [3]){1}; we need to set array size
3796                  now since later on array initializer will be just the
3797                  brace enclosed list of the compound literal.  */
3798               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3799               layout_type (type);
3800               layout_decl (decl, 0);
3801             }
3802         }
3803     }
3804 }
3805 \f
3806 /* Methods for storing and printing names for error messages.  */
3807
3808 /* Implement a spelling stack that allows components of a name to be pushed
3809    and popped.  Each element on the stack is this structure.  */
3810
3811 struct spelling
3812 {
3813   int kind;
3814   union
3815     {
3816       int i;
3817       const char *s;
3818     } u;
3819 };
3820
3821 #define SPELLING_STRING 1
3822 #define SPELLING_MEMBER 2
3823 #define SPELLING_BOUNDS 3
3824
3825 static struct spelling *spelling;       /* Next stack element (unused).  */
3826 static struct spelling *spelling_base;  /* Spelling stack base.  */
3827 static int spelling_size;               /* Size of the spelling stack.  */
3828
3829 /* Macros to save and restore the spelling stack around push_... functions.
3830    Alternative to SAVE_SPELLING_STACK.  */
3831
3832 #define SPELLING_DEPTH() (spelling - spelling_base)
3833 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3834
3835 /* Push an element on the spelling stack with type KIND and assign VALUE
3836    to MEMBER.  */
3837
3838 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
3839 {                                                                       \
3840   int depth = SPELLING_DEPTH ();                                        \
3841                                                                         \
3842   if (depth >= spelling_size)                                           \
3843     {                                                                   \
3844       spelling_size += 10;                                              \
3845       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
3846                                   spelling_size);                       \
3847       RESTORE_SPELLING_DEPTH (depth);                                   \
3848     }                                                                   \
3849                                                                         \
3850   spelling->kind = (KIND);                                              \
3851   spelling->MEMBER = (VALUE);                                           \
3852   spelling++;                                                           \
3853 }
3854
3855 /* Push STRING on the stack.  Printed literally.  */
3856
3857 static void
3858 push_string (const char *string)
3859 {
3860   PUSH_SPELLING (SPELLING_STRING, string, u.s);
3861 }
3862
3863 /* Push a member name on the stack.  Printed as '.' STRING.  */
3864
3865 static void
3866 push_member_name (tree decl)
3867 {
3868   const char *const string
3869     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3870   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3871 }
3872
3873 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
3874
3875 static void
3876 push_array_bounds (int bounds)
3877 {
3878   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
3879 }
3880
3881 /* Compute the maximum size in bytes of the printed spelling.  */
3882
3883 static int
3884 spelling_length (void)
3885 {
3886   int size = 0;
3887   struct spelling *p;
3888
3889   for (p = spelling_base; p < spelling; p++)
3890     {
3891       if (p->kind == SPELLING_BOUNDS)
3892         size += 25;
3893       else
3894         size += strlen (p->u.s) + 1;
3895     }
3896
3897   return size;
3898 }
3899
3900 /* Print the spelling to BUFFER and return it.  */
3901
3902 static char *
3903 print_spelling (char *buffer)
3904 {
3905   char *d = buffer;
3906   struct spelling *p;
3907
3908   for (p = spelling_base; p < spelling; p++)
3909     if (p->kind == SPELLING_BOUNDS)
3910       {
3911         sprintf (d, "[%d]", p->u.i);
3912         d += strlen (d);
3913       }
3914     else
3915       {
3916         const char *s;
3917         if (p->kind == SPELLING_MEMBER)
3918           *d++ = '.';
3919         for (s = p->u.s; (*d = *s++); d++)
3920           ;
3921       }
3922   *d++ = '\0';
3923   return buffer;
3924 }
3925
3926 /* Issue an error message for a bad initializer component.
3927    MSGID identifies the message.
3928    The component name is taken from the spelling stack.  */
3929
3930 void
3931 error_init (const char *msgid)
3932 {
3933   char *ofwhat;
3934
3935   error ("%s", _(msgid));
3936   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3937   if (*ofwhat)
3938     error ("(near initialization for `%s')", ofwhat);
3939 }
3940
3941 /* Issue a pedantic warning for a bad initializer component.
3942    MSGID identifies the message.
3943    The component name is taken from the spelling stack.  */
3944
3945 void
3946 pedwarn_init (const char *msgid)
3947 {
3948   char *ofwhat;
3949
3950   pedwarn ("%s", _(msgid));
3951   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3952   if (*ofwhat)
3953     pedwarn ("(near initialization for `%s')", ofwhat);
3954 }
3955
3956 /* Issue a warning for a bad initializer component.
3957    MSGID identifies the message.
3958    The component name is taken from the spelling stack.  */
3959
3960 static void
3961 warning_init (const char *msgid)
3962 {
3963   char *ofwhat;
3964
3965   warning ("%s", _(msgid));
3966   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
3967   if (*ofwhat)
3968     warning ("(near initialization for `%s')", ofwhat);
3969 }
3970 \f
3971 /* If TYPE is an array type and EXPR is a parenthesized string
3972    constant, warn if pedantic that EXPR is being used to initialize an
3973    object of type TYPE.  */
3974
3975 void
3976 maybe_warn_string_init (tree type, struct c_expr expr)
3977 {
3978   if (pedantic
3979       && TREE_CODE (type) == ARRAY_TYPE
3980       && TREE_CODE (expr.value) == STRING_CST
3981       && expr.original_code != STRING_CST)
3982     pedwarn_init ("array initialized from parenthesized string constant");
3983 }
3984
3985 /* Digest the parser output INIT as an initializer for type TYPE.
3986    Return a C expression of type TYPE to represent the initial value.
3987
3988    If INIT is a string constant, STRICT_STRING is true if it is
3989    unparenthesized or we should not warn here for it being parenthesized.
3990    For other types of INIT, STRICT_STRING is not used.
3991
3992    REQUIRE_CONSTANT requests an error if non-constant initializers or
3993    elements are seen.  */
3994
3995 static tree
3996 digest_init (tree type, tree init, bool strict_string, int require_constant)
3997 {
3998   enum tree_code code = TREE_CODE (type);
3999   tree inside_init = init;
4000
4001   if (type == error_mark_node
4002       || init == error_mark_node
4003       || TREE_TYPE (init) == error_mark_node)
4004     return error_mark_node;
4005
4006   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4007   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4008      whose value is 0 to count as a null pointer constant.  */
4009   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4010     inside_init = TREE_OPERAND (init, 0);
4011
4012   inside_init = fold (inside_init);
4013
4014   /* Initialization of an array of chars from a string constant
4015      optionally enclosed in braces.  */
4016
4017   if (code == ARRAY_TYPE && inside_init
4018       && TREE_CODE (inside_init) == STRING_CST)
4019     {
4020       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4021       /* Note that an array could be both an array of character type
4022          and an array of wchar_t if wchar_t is signed char or unsigned
4023          char.  */
4024       bool char_array = (typ1 == char_type_node
4025                          || typ1 == signed_char_type_node
4026                          || typ1 == unsigned_char_type_node);
4027       bool wchar_array = !!comptypes (typ1, wchar_type_node);
4028       if (char_array || wchar_array)
4029         {
4030           struct c_expr expr;
4031           bool char_string;
4032           expr.value = inside_init;
4033           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
4034           maybe_warn_string_init (type, expr);
4035
4036           char_string
4037             = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4038                == char_type_node);
4039
4040           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4041                          TYPE_MAIN_VARIANT (type)))
4042             return inside_init;
4043
4044           if (!wchar_array && !char_string)
4045             {
4046               error_init ("char-array initialized from wide string");
4047               return error_mark_node;
4048             }
4049           if (char_string && !char_array)
4050             {
4051               error_init ("wchar_t-array initialized from non-wide string");
4052               return error_mark_node;
4053             }
4054
4055           TREE_TYPE (inside_init) = type;
4056           if (TYPE_DOMAIN (type) != 0
4057               && TYPE_SIZE (type) != 0
4058               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4059               /* Subtract 1 (or sizeof (wchar_t))
4060                  because it's ok to ignore the terminating null char
4061                  that is counted in the length of the constant.  */
4062               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4063                                        TREE_STRING_LENGTH (inside_init)
4064                                        - ((TYPE_PRECISION (typ1)
4065                                            != TYPE_PRECISION (char_type_node))
4066                                           ? (TYPE_PRECISION (wchar_type_node)
4067                                              / BITS_PER_UNIT)
4068                                           : 1)))
4069             pedwarn_init ("initializer-string for array of chars is too long");
4070
4071           return inside_init;
4072         }
4073       else if (INTEGRAL_TYPE_P (typ1))
4074         {
4075           error_init ("array of inappropriate type initialized "
4076                       "from string constant");
4077           return error_mark_node;
4078         }
4079     }
4080
4081   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
4082      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4083      below and handle as a constructor.  */
4084     if (code == VECTOR_TYPE
4085         && TREE_CODE (TREE_TYPE (inside_init)) == 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                && !initializer_constant_valid_p (inside_init,
4170                                                  TREE_TYPE (inside_init)))
4171         {
4172           error_init ("initializer element is not constant");
4173           inside_init = error_mark_node;
4174         }
4175
4176       return inside_init;
4177     }
4178
4179   /* Handle scalar types, including conversions.  */
4180
4181   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4182       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
4183       || code == VECTOR_TYPE)
4184     {
4185       /* Note that convert_for_assignment calls default_conversion
4186          for arrays and functions.  We must not call it in the
4187          case where inside_init is a null pointer constant.  */
4188       inside_init
4189         = convert_for_assignment (type, init, _("initialization"),
4190                                   NULL_TREE, NULL_TREE, 0);
4191
4192       /* Check to see if we have already given an error message.  */
4193       if (inside_init == error_mark_node)
4194         ;
4195       else if (require_constant && ! TREE_CONSTANT (inside_init))
4196         {
4197           error_init ("initializer element is not constant");
4198           inside_init = error_mark_node;
4199         }
4200       else if (require_constant
4201                && !initializer_constant_valid_p (inside_init,
4202                                                  TREE_TYPE (inside_init)))
4203         {
4204           error_init ("initializer element is not computable at load time");
4205           inside_init = error_mark_node;
4206         }
4207
4208       return inside_init;
4209     }
4210
4211   /* Come here only for records and arrays.  */
4212
4213   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4214     {
4215       error_init ("variable-sized object may not be initialized");
4216       return error_mark_node;
4217     }
4218
4219   error_init ("invalid initializer");
4220   return error_mark_node;
4221 }
4222 \f
4223 /* Handle initializers that use braces.  */
4224
4225 /* Type of object we are accumulating a constructor for.
4226    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4227 static tree constructor_type;
4228
4229 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4230    left to fill.  */
4231 static tree constructor_fields;
4232
4233 /* For an ARRAY_TYPE, this is the specified index
4234    at which to store the next element we get.  */
4235 static tree constructor_index;
4236
4237 /* For an ARRAY_TYPE, this is the maximum index.  */
4238 static tree constructor_max_index;
4239
4240 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4241 static tree constructor_unfilled_fields;
4242
4243 /* For an ARRAY_TYPE, this is the index of the first element
4244    not yet written out.  */
4245 static tree constructor_unfilled_index;
4246
4247 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4248    This is so we can generate gaps between fields, when appropriate.  */
4249 static tree constructor_bit_index;
4250
4251 /* If we are saving up the elements rather than allocating them,
4252    this is the list of elements so far (in reverse order,
4253    most recent first).  */
4254 static tree constructor_elements;
4255
4256 /* 1 if constructor should be incrementally stored into a constructor chain,
4257    0 if all the elements should be kept in AVL tree.  */
4258 static int constructor_incremental;
4259
4260 /* 1 if so far this constructor's elements are all compile-time constants.  */
4261 static int constructor_constant;
4262
4263 /* 1 if so far this constructor's elements are all valid address constants.  */
4264 static int constructor_simple;
4265
4266 /* 1 if this constructor is erroneous so far.  */
4267 static int constructor_erroneous;
4268
4269 /* Structure for managing pending initializer elements, organized as an
4270    AVL tree.  */
4271
4272 struct init_node
4273 {
4274   struct init_node *left, *right;
4275   struct init_node *parent;
4276   int balance;
4277   tree purpose;
4278   tree value;
4279 };
4280
4281 /* Tree of pending elements at this constructor level.
4282    These are elements encountered out of order
4283    which belong at places we haven't reached yet in actually
4284    writing the output.
4285    Will never hold tree nodes across GC runs.  */
4286 static struct init_node *constructor_pending_elts;
4287
4288 /* The SPELLING_DEPTH of this constructor.  */
4289 static int constructor_depth;
4290
4291 /* 0 if implicitly pushing constructor levels is allowed.  */
4292 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4293
4294 /* DECL node for which an initializer is being read.
4295    0 means we are reading a constructor expression
4296    such as (struct foo) {...}.  */
4297 static tree constructor_decl;
4298
4299 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4300 static const char *constructor_asmspec;
4301
4302 /* Nonzero if this is an initializer for a top-level decl.  */
4303 static int constructor_top_level;
4304
4305 /* Nonzero if there were any member designators in this initializer.  */
4306 static int constructor_designated;
4307
4308 /* Nesting depth of designator list.  */
4309 static int designator_depth;
4310
4311 /* Nonzero if there were diagnosed errors in this designator list.  */
4312 static int designator_errorneous;
4313
4314 \f
4315 /* This stack has a level for each implicit or explicit level of
4316    structuring in the initializer, including the outermost one.  It
4317    saves the values of most of the variables above.  */
4318
4319 struct constructor_range_stack;
4320
4321 struct constructor_stack
4322 {
4323   struct constructor_stack *next;
4324   tree type;
4325   tree fields;
4326   tree index;
4327   tree max_index;
4328   tree unfilled_index;
4329   tree unfilled_fields;
4330   tree bit_index;
4331   tree elements;
4332   struct init_node *pending_elts;
4333   int offset;
4334   int depth;
4335   /* If value nonzero, this value should replace the entire
4336      constructor at this level.  */
4337   struct c_expr replacement_value;
4338   struct constructor_range_stack *range_stack;
4339   char constant;
4340   char simple;
4341   char implicit;
4342   char erroneous;
4343   char outer;
4344   char incremental;
4345   char designated;
4346 };
4347
4348 struct constructor_stack *constructor_stack;
4349
4350 /* This stack represents designators from some range designator up to
4351    the last designator in the list.  */
4352
4353 struct constructor_range_stack
4354 {
4355   struct constructor_range_stack *next, *prev;
4356   struct constructor_stack *stack;
4357   tree range_start;
4358   tree index;
4359   tree range_end;
4360   tree fields;
4361 };
4362
4363 struct constructor_range_stack *constructor_range_stack;
4364
4365 /* This stack records separate initializers that are nested.
4366    Nested initializers can't happen in ANSI C, but GNU C allows them
4367    in cases like { ... (struct foo) { ... } ... }.  */
4368
4369 struct initializer_stack
4370 {
4371   struct initializer_stack *next;
4372   tree decl;
4373   const char *asmspec;
4374   struct constructor_stack *constructor_stack;
4375   struct constructor_range_stack *constructor_range_stack;
4376   tree elements;
4377   struct spelling *spelling;
4378   struct spelling *spelling_base;
4379   int spelling_size;
4380   char top_level;
4381   char require_constant_value;
4382   char require_constant_elements;
4383 };
4384
4385 struct initializer_stack *initializer_stack;
4386 \f
4387 /* Prepare to parse and output the initializer for variable DECL.  */
4388
4389 void
4390 start_init (tree decl, tree asmspec_tree, int top_level)
4391 {
4392   const char *locus;
4393   struct initializer_stack *p = XNEW (struct initializer_stack);
4394   const char *asmspec = 0;
4395
4396   if (asmspec_tree)
4397     asmspec = TREE_STRING_POINTER (asmspec_tree);
4398
4399   p->decl = constructor_decl;
4400   p->asmspec = constructor_asmspec;
4401   p->require_constant_value = require_constant_value;
4402   p->require_constant_elements = require_constant_elements;
4403   p->constructor_stack = constructor_stack;
4404   p->constructor_range_stack = constructor_range_stack;
4405   p->elements = constructor_elements;
4406   p->spelling = spelling;
4407   p->spelling_base = spelling_base;
4408   p->spelling_size = spelling_size;
4409   p->top_level = constructor_top_level;
4410   p->next = initializer_stack;
4411   initializer_stack = p;
4412
4413   constructor_decl = decl;
4414   constructor_asmspec = asmspec;
4415   constructor_designated = 0;
4416   constructor_top_level = top_level;
4417
4418   if (decl != 0)
4419     {
4420       require_constant_value = TREE_STATIC (decl);
4421       require_constant_elements
4422         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4423            /* For a scalar, you can always use any value to initialize,
4424               even within braces.  */
4425            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4426                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4427                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4428                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4429       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4430     }
4431   else
4432     {
4433       require_constant_value = 0;
4434       require_constant_elements = 0;
4435       locus = "(anonymous)";
4436     }
4437
4438   constructor_stack = 0;
4439   constructor_range_stack = 0;
4440
4441   missing_braces_mentioned = 0;
4442
4443   spelling_base = 0;
4444   spelling_size = 0;
4445   RESTORE_SPELLING_DEPTH (0);
4446
4447   if (locus)
4448     push_string (locus);
4449 }
4450
4451 void
4452 finish_init (void)
4453 {
4454   struct initializer_stack *p = initializer_stack;
4455
4456   /* Free the whole constructor stack of this initializer.  */
4457   while (constructor_stack)
4458     {
4459       struct constructor_stack *q = constructor_stack;
4460       constructor_stack = q->next;
4461       free (q);
4462     }
4463
4464   gcc_assert (!constructor_range_stack);
4465
4466   /* Pop back to the data of the outer initializer (if any).  */
4467   free (spelling_base);
4468
4469   constructor_decl = p->decl;
4470   constructor_asmspec = p->asmspec;
4471   require_constant_value = p->require_constant_value;
4472   require_constant_elements = p->require_constant_elements;
4473   constructor_stack = p->constructor_stack;
4474   constructor_range_stack = p->constructor_range_stack;
4475   constructor_elements = p->elements;
4476   spelling = p->spelling;
4477   spelling_base = p->spelling_base;
4478   spelling_size = p->spelling_size;
4479   constructor_top_level = p->top_level;
4480   initializer_stack = p->next;
4481   free (p);
4482 }
4483 \f
4484 /* Call here when we see the initializer is surrounded by braces.
4485    This is instead of a call to push_init_level;
4486    it is matched by a call to pop_init_level.
4487
4488    TYPE is the type to initialize, for a constructor expression.
4489    For an initializer for a decl, TYPE is zero.  */
4490
4491 void
4492 really_start_incremental_init (tree type)
4493 {
4494   struct constructor_stack *p = XNEW (struct constructor_stack);
4495
4496   if (type == 0)
4497     type = TREE_TYPE (constructor_decl);
4498
4499   if (targetm.vector_opaque_p (type))
4500     error ("opaque vector types cannot be initialized");
4501
4502   p->type = constructor_type;
4503   p->fields = constructor_fields;
4504   p->index = constructor_index;
4505   p->max_index = constructor_max_index;
4506   p->unfilled_index = constructor_unfilled_index;
4507   p->unfilled_fields = constructor_unfilled_fields;
4508   p->bit_index = constructor_bit_index;
4509   p->elements = constructor_elements;
4510   p->constant = constructor_constant;
4511   p->simple = constructor_simple;
4512   p->erroneous = constructor_erroneous;
4513   p->pending_elts = constructor_pending_elts;
4514   p->depth = constructor_depth;
4515   p->replacement_value.value = 0;
4516   p->replacement_value.original_code = ERROR_MARK;
4517   p->implicit = 0;
4518   p->range_stack = 0;
4519   p->outer = 0;
4520   p->incremental = constructor_incremental;
4521   p->designated = constructor_designated;
4522   p->next = 0;
4523   constructor_stack = p;
4524
4525   constructor_constant = 1;
4526   constructor_simple = 1;
4527   constructor_depth = SPELLING_DEPTH ();
4528   constructor_elements = 0;
4529   constructor_pending_elts = 0;
4530   constructor_type = type;
4531   constructor_incremental = 1;
4532   constructor_designated = 0;
4533   designator_depth = 0;
4534   designator_errorneous = 0;
4535
4536   if (TREE_CODE (constructor_type) == RECORD_TYPE
4537       || TREE_CODE (constructor_type) == UNION_TYPE)
4538     {
4539       constructor_fields = TYPE_FIELDS (constructor_type);
4540       /* Skip any nameless bit fields at the beginning.  */
4541       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4542              && DECL_NAME (constructor_fields) == 0)
4543         constructor_fields = TREE_CHAIN (constructor_fields);
4544
4545       constructor_unfilled_fields = constructor_fields;
4546       constructor_bit_index = bitsize_zero_node;
4547     }
4548   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4549     {
4550       if (TYPE_DOMAIN (constructor_type))
4551         {
4552           constructor_max_index
4553             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4554
4555           /* Detect non-empty initializations of zero-length arrays.  */
4556           if (constructor_max_index == NULL_TREE
4557               && TYPE_SIZE (constructor_type))
4558             constructor_max_index = build_int_cst (NULL_TREE, -1);
4559
4560           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4561              to initialize VLAs will cause a proper error; avoid tree
4562              checking errors as well by setting a safe value.  */
4563           if (constructor_max_index
4564               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4565             constructor_max_index = build_int_cst (NULL_TREE, -1);
4566
4567           constructor_index
4568             = convert (bitsizetype,
4569                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4570         }
4571       else
4572         constructor_index = bitsize_zero_node;
4573
4574       constructor_unfilled_index = constructor_index;
4575     }
4576   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4577     {
4578       /* Vectors are like simple fixed-size arrays.  */
4579       constructor_max_index =
4580         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4581       constructor_index = convert (bitsizetype, bitsize_zero_node);
4582       constructor_unfilled_index = constructor_index;
4583     }
4584   else
4585     {
4586       /* Handle the case of int x = {5}; */
4587       constructor_fields = constructor_type;
4588       constructor_unfilled_fields = constructor_type;
4589     }
4590 }
4591 \f
4592 /* Push down into a subobject, for initialization.
4593    If this is for an explicit set of braces, IMPLICIT is 0.
4594    If it is because the next element belongs at a lower level,
4595    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4596
4597 void
4598 push_init_level (int implicit)
4599 {
4600   struct constructor_stack *p;
4601   tree value = NULL_TREE;
4602
4603   /* If we've exhausted any levels that didn't have braces,
4604      pop them now.  */
4605   while (constructor_stack->implicit)
4606     {
4607       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4608            || TREE_CODE (constructor_type) == UNION_TYPE)
4609           && constructor_fields == 0)
4610         process_init_element (pop_init_level (1));
4611       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4612                && constructor_max_index
4613                && tree_int_cst_lt (constructor_max_index, constructor_index))
4614         process_init_element (pop_init_level (1));
4615       else
4616         break;
4617     }
4618
4619   /* Unless this is an explicit brace, we need to preserve previous
4620      content if any.  */
4621   if (implicit)
4622     {
4623       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4624            || TREE_CODE (constructor_type) == UNION_TYPE)
4625           && constructor_fields)
4626         value = find_init_member (constructor_fields);
4627       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4628         value = find_init_member (constructor_index);
4629     }
4630
4631   p = XNEW (struct constructor_stack);
4632   p->type = constructor_type;
4633   p->fields = constructor_fields;
4634   p->index = constructor_index;
4635   p->max_index = constructor_max_index;
4636   p->unfilled_index = constructor_unfilled_index;
4637   p->unfilled_fields = constructor_unfilled_fields;
4638   p->bit_index = constructor_bit_index;
4639   p->elements = constructor_elements;
4640   p->constant = constructor_constant;
4641   p->simple = constructor_simple;
4642   p->erroneous = constructor_erroneous;
4643   p->pending_elts = constructor_pending_elts;
4644   p->depth = constructor_depth;
4645   p->replacement_value.value = 0;
4646   p->replacement_value.original_code = ERROR_MARK;
4647   p->implicit = implicit;
4648   p->outer = 0;
4649   p->incremental = constructor_incremental;
4650   p->designated = constructor_designated;
4651   p->next = constructor_stack;
4652   p->range_stack = 0;
4653   constructor_stack = p;
4654
4655   constructor_constant = 1;
4656   constructor_simple = 1;
4657   constructor_depth = SPELLING_DEPTH ();
4658   constructor_elements = 0;
4659   constructor_incremental = 1;
4660   constructor_designated = 0;
4661   constructor_pending_elts = 0;
4662   if (!implicit)
4663     {
4664       p->range_stack = constructor_range_stack;
4665       constructor_range_stack = 0;
4666       designator_depth = 0;
4667       designator_errorneous = 0;
4668     }
4669
4670   /* Don't die if an entire brace-pair level is superfluous
4671      in the containing level.  */
4672   if (constructor_type == 0)
4673     ;
4674   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4675            || TREE_CODE (constructor_type) == UNION_TYPE)
4676     {
4677       /* Don't die if there are extra init elts at the end.  */
4678       if (constructor_fields == 0)
4679         constructor_type = 0;
4680       else
4681         {
4682           constructor_type = TREE_TYPE (constructor_fields);
4683           push_member_name (constructor_fields);
4684           constructor_depth++;
4685         }
4686     }
4687   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4688     {
4689       constructor_type = TREE_TYPE (constructor_type);
4690       push_array_bounds (tree_low_cst (constructor_index, 0));
4691       constructor_depth++;
4692     }
4693
4694   if (constructor_type == 0)
4695     {
4696       error_init ("extra brace group at end of initializer");
4697       constructor_fields = 0;
4698       constructor_unfilled_fields = 0;
4699       return;
4700     }
4701
4702   if (value && TREE_CODE (value) == CONSTRUCTOR)
4703     {
4704       constructor_constant = TREE_CONSTANT (value);
4705       constructor_simple = TREE_STATIC (value);
4706       constructor_elements = CONSTRUCTOR_ELTS (value);
4707       if (constructor_elements
4708           && (TREE_CODE (constructor_type) == RECORD_TYPE
4709               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4710         set_nonincremental_init ();
4711     }
4712
4713   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4714     {
4715       missing_braces_mentioned = 1;
4716       warning_init ("missing braces around initializer");
4717     }
4718
4719   if (TREE_CODE (constructor_type) == RECORD_TYPE
4720            || TREE_CODE (constructor_type) == UNION_TYPE)
4721     {
4722       constructor_fields = TYPE_FIELDS (constructor_type);
4723       /* Skip any nameless bit fields at the beginning.  */
4724       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4725              && DECL_NAME (constructor_fields) == 0)
4726         constructor_fields = TREE_CHAIN (constructor_fields);
4727
4728       constructor_unfilled_fields = constructor_fields;
4729       constructor_bit_index = bitsize_zero_node;
4730     }
4731   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4732     {
4733       /* Vectors are like simple fixed-size arrays.  */
4734       constructor_max_index =
4735         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4736       constructor_index = convert (bitsizetype, integer_zero_node);
4737       constructor_unfilled_index = constructor_index;
4738     }
4739   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4740     {
4741       if (TYPE_DOMAIN (constructor_type))
4742         {
4743           constructor_max_index
4744             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4745
4746           /* Detect non-empty initializations of zero-length arrays.  */
4747           if (constructor_max_index == NULL_TREE
4748               && TYPE_SIZE (constructor_type))
4749             constructor_max_index = build_int_cst (NULL_TREE, -1);
4750
4751           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4752              to initialize VLAs will cause a proper error; avoid tree
4753              checking errors as well by setting a safe value.  */
4754           if (constructor_max_index
4755               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4756             constructor_max_index = build_int_cst (NULL_TREE, -1);
4757
4758           constructor_index
4759             = convert (bitsizetype,
4760                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4761         }
4762       else
4763         constructor_index = bitsize_zero_node;
4764
4765       constructor_unfilled_index = constructor_index;
4766       if (value && TREE_CODE (value) == STRING_CST)
4767         {
4768           /* We need to split the char/wchar array into individual
4769              characters, so that we don't have to special case it
4770              everywhere.  */
4771           set_nonincremental_init_from_string (value);
4772         }
4773     }
4774   else
4775     {
4776       warning_init ("braces around scalar initializer");
4777       constructor_fields = constructor_type;
4778       constructor_unfilled_fields = constructor_type;
4779     }
4780 }
4781
4782 /* At the end of an implicit or explicit brace level,
4783    finish up that level of constructor.  If a single expression
4784    with redundant braces initialized that level, return the
4785    c_expr structure for that expression.  Otherwise, the original_code
4786    element is set to ERROR_MARK.
4787    If we were outputting the elements as they are read, return 0 as the value
4788    from inner levels (process_init_element ignores that),
4789    but return error_mark_node as the value from the outermost level
4790    (that's what we want to put in DECL_INITIAL).
4791    Otherwise, return a CONSTRUCTOR expression as the value.  */
4792
4793 struct c_expr
4794 pop_init_level (int implicit)
4795 {
4796   struct constructor_stack *p;
4797   struct c_expr ret;
4798   ret.value = 0;
4799   ret.original_code = ERROR_MARK;
4800
4801   if (implicit == 0)
4802     {
4803       /* When we come to an explicit close brace,
4804          pop any inner levels that didn't have explicit braces.  */
4805       while (constructor_stack->implicit)
4806         process_init_element (pop_init_level (1));
4807
4808       gcc_assert (!constructor_range_stack);
4809     }
4810
4811   /* Now output all pending elements.  */
4812   constructor_incremental = 1;
4813   output_pending_init_elements (1);
4814
4815   p = constructor_stack;
4816
4817   /* Error for initializing a flexible array member, or a zero-length
4818      array member in an inappropriate context.  */
4819   if (constructor_type && constructor_fields
4820       && TREE_CODE (constructor_type) == ARRAY_TYPE
4821       && TYPE_DOMAIN (constructor_type)
4822       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4823     {
4824       /* Silently discard empty initializations.  The parser will
4825          already have pedwarned for empty brackets.  */
4826       if (integer_zerop (constructor_unfilled_index))
4827         constructor_type = NULL_TREE;
4828       else
4829         {
4830           gcc_assert (!TYPE_SIZE (constructor_type));
4831
4832           if (constructor_depth > 2)
4833             error_init ("initialization of flexible array member in a nested context");
4834           else if (pedantic)
4835             pedwarn_init ("initialization of a flexible array member");
4836
4837           /* We have already issued an error message for the existence
4838              of a flexible array member not at the end of the structure.
4839              Discard the initializer so that we do not abort later.  */
4840           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4841             constructor_type = NULL_TREE;
4842         }
4843     }
4844
4845   /* Warn when some struct elements are implicitly initialized to zero.  */
4846   if (warn_missing_field_initializers
4847       && constructor_type
4848       && TREE_CODE (constructor_type) == RECORD_TYPE
4849       && constructor_unfilled_fields)
4850     {
4851         /* Do not warn for flexible array members or zero-length arrays.  */
4852         while (constructor_unfilled_fields
4853                && (! DECL_SIZE (constructor_unfilled_fields)
4854                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4855           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4856
4857         /* Do not warn if this level of the initializer uses member
4858            designators; it is likely to be deliberate.  */
4859         if (constructor_unfilled_fields && !constructor_designated)
4860           {
4861             push_member_name (constructor_unfilled_fields);
4862             warning_init ("missing initializer");
4863             RESTORE_SPELLING_DEPTH (constructor_depth);
4864           }
4865     }
4866
4867   /* Pad out the end of the structure.  */
4868   if (p->replacement_value.value)
4869     /* If this closes a superfluous brace pair,
4870        just pass out the element between them.  */
4871     ret = p->replacement_value;
4872   else if (constructor_type == 0)
4873     ;
4874   else if (TREE_CODE (constructor_type) != RECORD_TYPE
4875            && TREE_CODE (constructor_type) != UNION_TYPE
4876            && TREE_CODE (constructor_type) != ARRAY_TYPE
4877            && TREE_CODE (constructor_type) != VECTOR_TYPE)
4878     {
4879       /* A nonincremental scalar initializer--just return
4880          the element, after verifying there is just one.  */
4881       if (constructor_elements == 0)
4882         {
4883           if (!constructor_erroneous)
4884             error_init ("empty scalar initializer");
4885           ret.value = error_mark_node;
4886         }
4887       else if (TREE_CHAIN (constructor_elements) != 0)
4888         {
4889           error_init ("extra elements in scalar initializer");
4890           ret.value = TREE_VALUE (constructor_elements);
4891         }
4892       else
4893         ret.value = TREE_VALUE (constructor_elements);
4894     }
4895   else
4896     {
4897       if (constructor_erroneous)
4898         ret.value = error_mark_node;
4899       else
4900         {
4901           ret.value = build_constructor (constructor_type,
4902                                          nreverse (constructor_elements));
4903           if (constructor_constant)
4904             TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
4905           if (constructor_constant && constructor_simple)
4906             TREE_STATIC (ret.value) = 1;
4907         }
4908     }
4909
4910   constructor_type = p->type;
4911   constructor_fields = p->fields;
4912   constructor_index = p->index;
4913   constructor_max_index = p->max_index;
4914   constructor_unfilled_index = p->unfilled_index;
4915   constructor_unfilled_fields = p->unfilled_fields;
4916   constructor_bit_index = p->bit_index;
4917   constructor_elements = p->elements;
4918   constructor_constant = p->constant;
4919   constructor_simple = p->simple;
4920   constructor_erroneous = p->erroneous;
4921   constructor_incremental = p->incremental;
4922   constructor_designated = p->designated;
4923   constructor_pending_elts = p->pending_elts;
4924   constructor_depth = p->depth;
4925   if (!p->implicit)
4926     constructor_range_stack = p->range_stack;
4927   RESTORE_SPELLING_DEPTH (constructor_depth);
4928
4929   constructor_stack = p->next;
4930   free (p);
4931
4932   if (ret.value == 0)
4933     {
4934       if (constructor_stack == 0)
4935         {
4936           ret.value = error_mark_node;
4937           return ret;
4938         }
4939       return ret;
4940     }
4941   return ret;
4942 }
4943
4944 /* Common handling for both array range and field name designators.
4945    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
4946
4947 static int
4948 set_designator (int array)
4949 {
4950   tree subtype;
4951   enum tree_code subcode;
4952
4953   /* Don't die if an entire brace-pair level is superfluous
4954      in the containing level.  */
4955   if (constructor_type == 0)
4956     return 1;
4957
4958   /* If there were errors in this designator list already, bail out
4959      silently.  */
4960   if (designator_errorneous)
4961     return 1;
4962
4963   if (!designator_depth)
4964     {
4965       gcc_assert (!constructor_range_stack);
4966
4967       /* Designator list starts at the level of closest explicit
4968          braces.  */
4969       while (constructor_stack->implicit)
4970         process_init_element (pop_init_level (1));
4971       constructor_designated = 1;
4972       return 0;
4973     }
4974
4975   if (constructor_no_implicit)
4976     {
4977       error_init ("initialization designators may not nest");
4978       return 1;
4979     }
4980
4981   switch (TREE_CODE (constructor_type))
4982     {
4983     case  RECORD_TYPE:
4984     case  UNION_TYPE:
4985       subtype = TREE_TYPE (constructor_fields);
4986       if (subtype != error_mark_node)
4987         subtype = TYPE_MAIN_VARIANT (subtype);
4988       break;
4989     case ARRAY_TYPE:
4990       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
4991       break;
4992     default:
4993       gcc_unreachable ();
4994     }
4995
4996   subcode = TREE_CODE (subtype);
4997   if (array && subcode != ARRAY_TYPE)
4998     {
4999       error_init ("array index in non-array initializer");
5000       return 1;
5001     }
5002   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5003     {
5004       error_init ("field name not in record or union initializer");
5005       return 1;
5006     }
5007
5008   constructor_designated = 1;
5009   push_init_level (2);
5010   return 0;
5011 }
5012
5013 /* If there are range designators in designator list, push a new designator
5014    to constructor_range_stack.  RANGE_END is end of such stack range or
5015    NULL_TREE if there is no range designator at this level.  */
5016
5017 static void
5018 push_range_stack (tree range_end)
5019 {
5020   struct constructor_range_stack *p;
5021
5022   p = GGC_NEW (struct constructor_range_stack);
5023   p->prev = constructor_range_stack;
5024   p->next = 0;
5025   p->fields = constructor_fields;
5026   p->range_start = constructor_index;
5027   p->index = constructor_index;
5028   p->stack = constructor_stack;
5029   p->range_end = range_end;
5030   if (constructor_range_stack)
5031     constructor_range_stack->next = p;
5032   constructor_range_stack = p;
5033 }
5034
5035 /* Within an array initializer, specify the next index to be initialized.
5036    FIRST is that index.  If LAST is nonzero, then initialize a range
5037    of indices, running from FIRST through LAST.  */
5038
5039 void
5040 set_init_index (tree first, tree last)
5041 {
5042   if (set_designator (1))
5043     return;
5044
5045   designator_errorneous = 1;
5046
5047   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
5048       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
5049     {
5050       error_init ("array index in initializer not of integer type");
5051       return;
5052     }
5053
5054   while ((TREE_CODE (first) == NOP_EXPR
5055           || TREE_CODE (first) == CONVERT_EXPR
5056           || TREE_CODE (first) == NON_LVALUE_EXPR)
5057          && (TYPE_MODE (TREE_TYPE (first))
5058              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5059     first = TREE_OPERAND (first, 0);
5060
5061   if (last)
5062     while ((TREE_CODE (last) == NOP_EXPR
5063             || TREE_CODE (last) == CONVERT_EXPR
5064             || TREE_CODE (last) == NON_LVALUE_EXPR)
5065            && (TYPE_MODE (TREE_TYPE (last))
5066                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5067       last = TREE_OPERAND (last, 0);
5068
5069   if (TREE_CODE (first) != INTEGER_CST)
5070     error_init ("nonconstant array index in initializer");
5071   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5072     error_init ("nonconstant array index in initializer");
5073   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5074     error_init ("array index in non-array initializer");
5075   else if (tree_int_cst_sgn (first) == -1)
5076     error_init ("array index in initializer exceeds array bounds");
5077   else if (constructor_max_index
5078            && tree_int_cst_lt (constructor_max_index, first))
5079     error_init ("array index in initializer exceeds array bounds");
5080   else
5081     {
5082       constructor_index = convert (bitsizetype, first);
5083
5084       if (last)
5085         {
5086           if (tree_int_cst_equal (first, last))
5087             last = 0;
5088           else if (tree_int_cst_lt (last, first))
5089             {
5090               error_init ("empty index range in initializer");
5091               last = 0;
5092             }
5093           else
5094             {
5095               last = convert (bitsizetype, last);
5096               if (constructor_max_index != 0
5097                   && tree_int_cst_lt (constructor_max_index, last))
5098                 {
5099                   error_init ("array index range in initializer exceeds array bounds");
5100                   last = 0;
5101                 }
5102             }
5103         }
5104
5105       designator_depth++;
5106       designator_errorneous = 0;
5107       if (constructor_range_stack || last)
5108         push_range_stack (last);
5109     }
5110 }
5111
5112 /* Within a struct initializer, specify the next field to be initialized.  */
5113
5114 void
5115 set_init_label (tree fieldname)
5116 {
5117   tree tail;
5118
5119   if (set_designator (0))
5120     return;
5121
5122   designator_errorneous = 1;
5123
5124   if (TREE_CODE (constructor_type) != RECORD_TYPE
5125       && TREE_CODE (constructor_type) != UNION_TYPE)
5126     {
5127       error_init ("field name not in record or union initializer");
5128       return;
5129     }
5130
5131   for (tail = TYPE_FIELDS (constructor_type); tail;
5132        tail = TREE_CHAIN (tail))
5133     {
5134       if (DECL_NAME (tail) == fieldname)
5135         break;
5136     }
5137
5138   if (tail == 0)
5139     error ("unknown field `%s' specified in initializer",
5140            IDENTIFIER_POINTER (fieldname));
5141   else
5142     {
5143       constructor_fields = tail;
5144       designator_depth++;
5145       designator_errorneous = 0;
5146       if (constructor_range_stack)
5147         push_range_stack (NULL_TREE);
5148     }
5149 }
5150 \f
5151 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5152    identifies the initializer, either array index or field in a structure.
5153    VALUE is the value of that index or field.  */
5154
5155 static void
5156 add_pending_init (tree purpose, tree value)
5157 {
5158   struct init_node *p, **q, *r;
5159
5160   q = &constructor_pending_elts;
5161   p = 0;
5162
5163   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5164     {
5165       while (*q != 0)
5166         {
5167           p = *q;
5168           if (tree_int_cst_lt (purpose, p->purpose))
5169             q = &p->left;
5170           else if (tree_int_cst_lt (p->purpose, purpose))
5171             q = &p->right;
5172           else
5173             {
5174               if (TREE_SIDE_EFFECTS (p->value))
5175                 warning_init ("initialized field with side-effects overwritten");
5176               p->value = value;
5177               return;
5178             }
5179         }
5180     }
5181   else
5182     {
5183       tree bitpos;
5184
5185       bitpos = bit_position (purpose);
5186       while (*q != NULL)
5187         {
5188           p = *q;
5189           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5190             q = &p->left;
5191           else if (p->purpose != purpose)
5192             q = &p->right;
5193           else
5194             {
5195               if (TREE_SIDE_EFFECTS (p->value))
5196                 warning_init ("initialized field with side-effects overwritten");
5197               p->value = value;
5198               return;
5199             }
5200         }
5201     }
5202
5203   r = GGC_NEW (struct init_node);
5204   r->purpose = purpose;
5205   r->value = value;
5206
5207   *q = r;
5208   r->parent = p;
5209   r->left = 0;
5210   r->right = 0;
5211   r->balance = 0;
5212
5213   while (p)
5214     {
5215       struct init_node *s;
5216
5217       if (r == p->left)
5218         {
5219           if (p->balance == 0)
5220             p->balance = -1;
5221           else if (p->balance < 0)
5222             {
5223               if (r->balance < 0)
5224                 {
5225                   /* L rotation.  */
5226                   p->left = r->right;
5227                   if (p->left)
5228                     p->left->parent = p;
5229                   r->right = p;
5230
5231                   p->balance = 0;
5232                   r->balance = 0;
5233
5234                   s = p->parent;
5235                   p->parent = r;
5236                   r->parent = s;
5237                   if (s)
5238                     {
5239                       if (s->left == p)
5240                         s->left = r;
5241                       else
5242                         s->right = r;
5243                     }
5244                   else
5245                     constructor_pending_elts = r;
5246                 }
5247               else
5248                 {
5249                   /* LR rotation.  */
5250                   struct init_node *t = r->right;
5251
5252                   r->right = t->left;
5253                   if (r->right)
5254                     r->right->parent = r;
5255                   t->left = r;
5256
5257                   p->left = t->right;
5258                   if (p->left)
5259                     p->left->parent = p;
5260                   t->right = p;
5261
5262                   p->balance = t->balance < 0;
5263                   r->balance = -(t->balance > 0);
5264                   t->balance = 0;
5265
5266                   s = p->parent;
5267                   p->parent = t;
5268                   r->parent = t;
5269                   t->parent = s;
5270                   if (s)
5271                     {
5272                       if (s->left == p)
5273                         s->left = t;
5274                       else
5275                         s->right = t;
5276                     }
5277                   else
5278                     constructor_pending_elts = t;
5279                 }
5280               break;
5281             }
5282           else
5283             {
5284               /* p->balance == +1; growth of left side balances the node.  */
5285               p->balance = 0;
5286               break;
5287             }
5288         }
5289       else /* r == p->right */
5290         {
5291           if (p->balance == 0)
5292             /* Growth propagation from right side.  */
5293             p->balance++;
5294           else if (p->balance > 0)
5295             {
5296               if (r->balance > 0)
5297                 {
5298                   /* R rotation.  */
5299                   p->right = r->left;
5300                   if (p->right)
5301                     p->right->parent = p;
5302                   r->left = p;
5303
5304                   p->balance = 0;
5305                   r->balance = 0;
5306
5307                   s = p->parent;
5308                   p->parent = r;
5309                   r->parent = s;
5310                   if (s)
5311                     {
5312                       if (s->left == p)
5313                         s->left = r;
5314                       else
5315                         s->right = r;
5316                     }
5317                   else
5318                     constructor_pending_elts = r;
5319                 }
5320               else /* r->balance == -1 */
5321                 {
5322                   /* RL rotation */
5323                   struct init_node *t = r->left;
5324
5325                   r->left = t->right;
5326                   if (r->left)
5327                     r->left->parent = r;
5328                   t->right = r;
5329
5330                   p->right = t->left;
5331                   if (p->right)
5332                     p->right->parent = p;
5333                   t->left = p;
5334
5335                   r->balance = (t->balance < 0);
5336                   p->balance = -(t->balance > 0);
5337                   t->balance = 0;
5338
5339                   s = p->parent;
5340                   p->parent = t;
5341                   r->parent = t;
5342                   t->parent = s;
5343                   if (s)
5344                     {
5345                       if (s->left == p)
5346                         s->left = t;
5347                       else
5348                         s->right = t;
5349                     }
5350                   else
5351                     constructor_pending_elts = t;
5352                 }
5353               break;
5354             }
5355           else
5356             {
5357               /* p->balance == -1; growth of right side balances the node.  */
5358               p->balance = 0;
5359               break;
5360             }
5361         }
5362
5363       r = p;
5364       p = p->parent;
5365     }
5366 }
5367
5368 /* Build AVL tree from a sorted chain.  */
5369
5370 static void
5371 set_nonincremental_init (void)
5372 {
5373   tree chain;
5374
5375   if (TREE_CODE (constructor_type) != RECORD_TYPE
5376       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5377     return;
5378
5379   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5380     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5381   constructor_elements = 0;
5382   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5383     {
5384       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5385       /* Skip any nameless bit fields at the beginning.  */
5386       while (constructor_unfilled_fields != 0
5387              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5388              && DECL_NAME (constructor_unfilled_fields) == 0)
5389         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5390
5391     }
5392   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5393     {
5394       if (TYPE_DOMAIN (constructor_type))
5395         constructor_unfilled_index
5396             = convert (bitsizetype,
5397                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5398       else
5399         constructor_unfilled_index = bitsize_zero_node;
5400     }
5401   constructor_incremental = 0;
5402 }
5403
5404 /* Build AVL tree from a string constant.  */
5405
5406 static void
5407 set_nonincremental_init_from_string (tree str)
5408 {
5409   tree value, purpose, type;
5410   HOST_WIDE_INT val[2];
5411   const char *p, *end;
5412   int byte, wchar_bytes, charwidth, bitpos;
5413
5414   gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
5415
5416   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5417       == TYPE_PRECISION (char_type_node))
5418     wchar_bytes = 1;
5419   else
5420     {
5421       gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5422                   == TYPE_PRECISION (wchar_type_node));
5423       wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5424     }
5425   charwidth = TYPE_PRECISION (char_type_node);
5426   type = TREE_TYPE (constructor_type);
5427   p = TREE_STRING_POINTER (str);
5428   end = p + TREE_STRING_LENGTH (str);
5429
5430   for (purpose = bitsize_zero_node;
5431        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5432        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5433     {
5434       if (wchar_bytes == 1)
5435         {
5436           val[1] = (unsigned char) *p++;
5437           val[0] = 0;
5438         }
5439       else
5440         {
5441           val[0] = 0;
5442           val[1] = 0;
5443           for (byte = 0; byte < wchar_bytes; byte++)
5444             {
5445               if (BYTES_BIG_ENDIAN)
5446                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5447               else
5448                 bitpos = byte * charwidth;
5449               val[bitpos < HOST_BITS_PER_WIDE_INT]
5450                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5451                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5452             }
5453         }
5454
5455       if (!TYPE_UNSIGNED (type))
5456         {
5457           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5458           if (bitpos < HOST_BITS_PER_WIDE_INT)
5459             {
5460               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5461                 {
5462                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5463                   val[0] = -1;
5464                 }
5465             }
5466           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5467             {
5468               if (val[1] < 0)
5469                 val[0] = -1;
5470             }
5471           else if (val[0] & (((HOST_WIDE_INT) 1)
5472                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5473             val[0] |= ((HOST_WIDE_INT) -1)
5474                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5475         }
5476
5477       value = build_int_cst_wide (type, val[1], val[0]);
5478       add_pending_init (purpose, value);
5479     }
5480
5481   constructor_incremental = 0;
5482 }
5483
5484 /* Return value of FIELD in pending initializer or zero if the field was
5485    not initialized yet.  */
5486
5487 static tree
5488 find_init_member (tree field)
5489 {
5490   struct init_node *p;
5491
5492   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5493     {
5494       if (constructor_incremental
5495           && tree_int_cst_lt (field, constructor_unfilled_index))
5496         set_nonincremental_init ();
5497
5498       p = constructor_pending_elts;
5499       while (p)
5500         {
5501           if (tree_int_cst_lt (field, p->purpose))
5502             p = p->left;
5503           else if (tree_int_cst_lt (p->purpose, field))
5504             p = p->right;
5505           else
5506             return p->value;
5507         }
5508     }
5509   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5510     {
5511       tree bitpos = bit_position (field);
5512
5513       if (constructor_incremental
5514           && (!constructor_unfilled_fields
5515               || tree_int_cst_lt (bitpos,
5516                                   bit_position (constructor_unfilled_fields))))
5517         set_nonincremental_init ();
5518
5519       p = constructor_pending_elts;
5520       while (p)
5521         {
5522           if (field == p->purpose)
5523             return p->value;
5524           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5525             p = p->left;
5526           else
5527             p = p->right;
5528         }
5529     }
5530   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5531     {
5532       if (constructor_elements
5533           && TREE_PURPOSE (constructor_elements) == field)
5534         return TREE_VALUE (constructor_elements);
5535     }
5536   return 0;
5537 }
5538
5539 /* "Output" the next constructor element.
5540    At top level, really output it to assembler code now.
5541    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5542    TYPE is the data type that the containing data type wants here.
5543    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5544    If VALUE is a string constant, STRICT_STRING is true if it is
5545    unparenthesized or we should not warn here for it being parenthesized.
5546    For other types of VALUE, STRICT_STRING is not used.
5547
5548    PENDING if non-nil means output pending elements that belong
5549    right after this element.  (PENDING is normally 1;
5550    it is 0 while outputting pending elements, to avoid recursion.)  */
5551
5552 static void
5553 output_init_element (tree value, bool strict_string, tree type, tree field,
5554                      int pending)
5555 {
5556   if (type == error_mark_node)
5557     {
5558       constructor_erroneous = 1;
5559       return;
5560     }
5561   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5562       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5563           && !(TREE_CODE (value) == STRING_CST
5564                && TREE_CODE (type) == ARRAY_TYPE
5565                && INTEGRAL_TYPE_P (TREE_TYPE (type)))
5566           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5567                          TYPE_MAIN_VARIANT (type))))
5568     value = default_conversion (value);
5569
5570   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5571       && require_constant_value && !flag_isoc99 && pending)
5572     {
5573       /* As an extension, allow initializing objects with static storage
5574          duration with compound literals (which are then treated just as
5575          the brace enclosed list they contain).  */
5576       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5577       value = DECL_INITIAL (decl);
5578     }
5579
5580   if (value == error_mark_node)
5581     constructor_erroneous = 1;
5582   else if (!TREE_CONSTANT (value))
5583     constructor_constant = 0;
5584   else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
5585            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5586                 || TREE_CODE (constructor_type) == UNION_TYPE)
5587                && DECL_C_BIT_FIELD (field)
5588                && TREE_CODE (value) != INTEGER_CST))
5589     constructor_simple = 0;
5590
5591   if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
5592     {
5593       if (require_constant_value)
5594         {
5595           error_init ("initializer element is not constant");
5596           value = error_mark_node;
5597         }
5598       else if (require_constant_elements)
5599         pedwarn ("initializer element is not computable at load time");
5600     }
5601
5602   /* If this field is empty (and not at the end of structure),
5603      don't do anything other than checking the initializer.  */
5604   if (field
5605       && (TREE_TYPE (field) == error_mark_node
5606           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5607               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5608               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5609                   || TREE_CHAIN (field)))))
5610     return;
5611
5612   value = digest_init (type, value, strict_string, require_constant_value);
5613   if (value == error_mark_node)
5614     {
5615       constructor_erroneous = 1;
5616       return;
5617     }
5618
5619   /* If this element doesn't come next in sequence,
5620      put it on constructor_pending_elts.  */
5621   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5622       && (!constructor_incremental
5623           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5624     {
5625       if (constructor_incremental
5626           && tree_int_cst_lt (field, constructor_unfilled_index))
5627         set_nonincremental_init ();
5628
5629       add_pending_init (field, value);
5630       return;
5631     }
5632   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5633            && (!constructor_incremental
5634                || field != constructor_unfilled_fields))
5635     {
5636       /* We do this for records but not for unions.  In a union,
5637          no matter which field is specified, it can be initialized
5638          right away since it starts at the beginning of the union.  */
5639       if (constructor_incremental)
5640         {
5641           if (!constructor_unfilled_fields)
5642             set_nonincremental_init ();
5643           else
5644             {
5645               tree bitpos, unfillpos;
5646
5647               bitpos = bit_position (field);
5648               unfillpos = bit_position (constructor_unfilled_fields);
5649
5650               if (tree_int_cst_lt (bitpos, unfillpos))
5651                 set_nonincremental_init ();
5652             }
5653         }
5654
5655       add_pending_init (field, value);
5656       return;
5657     }
5658   else if (TREE_CODE (constructor_type) == UNION_TYPE
5659            && constructor_elements)
5660     {
5661       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5662         warning_init ("initialized field with side-effects overwritten");
5663
5664       /* We can have just one union field set.  */
5665       constructor_elements = 0;
5666     }
5667
5668   /* Otherwise, output this element either to
5669      constructor_elements or to the assembler file.  */
5670
5671   if (field && TREE_CODE (field) == INTEGER_CST)
5672     field = copy_node (field);
5673   constructor_elements
5674     = tree_cons (field, value, constructor_elements);
5675
5676   /* Advance the variable that indicates sequential elements output.  */
5677   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5678     constructor_unfilled_index
5679       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5680                     bitsize_one_node);
5681   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5682     {
5683       constructor_unfilled_fields
5684         = TREE_CHAIN (constructor_unfilled_fields);
5685
5686       /* Skip any nameless bit fields.  */
5687       while (constructor_unfilled_fields != 0
5688              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5689              && DECL_NAME (constructor_unfilled_fields) == 0)
5690         constructor_unfilled_fields =
5691           TREE_CHAIN (constructor_unfilled_fields);
5692     }
5693   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5694     constructor_unfilled_fields = 0;
5695
5696   /* Now output any pending elements which have become next.  */
5697   if (pending)
5698     output_pending_init_elements (0);
5699 }
5700
5701 /* Output any pending elements which have become next.
5702    As we output elements, constructor_unfilled_{fields,index}
5703    advances, which may cause other elements to become next;
5704    if so, they too are output.
5705
5706    If ALL is 0, we return when there are
5707    no more pending elements to output now.
5708
5709    If ALL is 1, we output space as necessary so that
5710    we can output all the pending elements.  */
5711
5712 static void
5713 output_pending_init_elements (int all)
5714 {
5715   struct init_node *elt = constructor_pending_elts;
5716   tree next;
5717
5718  retry:
5719
5720   /* Look through the whole pending tree.
5721      If we find an element that should be output now,
5722      output it.  Otherwise, set NEXT to the element
5723      that comes first among those still pending.  */
5724
5725   next = 0;
5726   while (elt)
5727     {
5728       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5729         {
5730           if (tree_int_cst_equal (elt->purpose,
5731                                   constructor_unfilled_index))
5732             output_init_element (elt->value, true,
5733                                  TREE_TYPE (constructor_type),
5734                                  constructor_unfilled_index, 0);
5735           else if (tree_int_cst_lt (constructor_unfilled_index,
5736                                     elt->purpose))
5737             {
5738               /* Advance to the next smaller node.  */
5739               if (elt->left)
5740                 elt = elt->left;
5741               else
5742                 {
5743                   /* We have reached the smallest node bigger than the
5744                      current unfilled index.  Fill the space first.  */
5745                   next = elt->purpose;
5746                   break;
5747                 }
5748             }
5749           else
5750             {
5751               /* Advance to the next bigger node.  */
5752               if (elt->right)
5753                 elt = elt->right;
5754               else
5755                 {
5756                   /* We have reached the biggest node in a subtree.  Find
5757                      the parent of it, which is the next bigger node.  */
5758                   while (elt->parent && elt->parent->right == elt)
5759                     elt = elt->parent;
5760                   elt = elt->parent;
5761                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5762                                               elt->purpose))
5763                     {
5764                       next = elt->purpose;
5765                       break;
5766                     }
5767                 }
5768             }
5769         }
5770       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5771                || TREE_CODE (constructor_type) == UNION_TYPE)
5772         {
5773           tree ctor_unfilled_bitpos, elt_bitpos;
5774
5775           /* If the current record is complete we are done.  */
5776           if (constructor_unfilled_fields == 0)
5777             break;
5778
5779           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5780           elt_bitpos = bit_position (elt->purpose);
5781           /* We can't compare fields here because there might be empty
5782              fields in between.  */
5783           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5784             {
5785               constructor_unfilled_fields = elt->purpose;
5786               output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
5787                                    elt->purpose, 0);
5788             }
5789           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5790             {
5791               /* Advance to the next smaller node.  */
5792               if (elt->left)
5793                 elt = elt->left;
5794               else
5795                 {
5796                   /* We have reached the smallest node bigger than the
5797                      current unfilled field.  Fill the space first.  */
5798                   next = elt->purpose;
5799                   break;
5800                 }
5801             }
5802           else
5803             {
5804               /* Advance to the next bigger node.  */
5805               if (elt->right)
5806                 elt = elt->right;
5807               else
5808                 {
5809                   /* We have reached the biggest node in a subtree.  Find
5810                      the parent of it, which is the next bigger node.  */
5811                   while (elt->parent && elt->parent->right == elt)
5812                     elt = elt->parent;
5813                   elt = elt->parent;
5814                   if (elt
5815                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
5816                                            bit_position (elt->purpose))))
5817                     {
5818                       next = elt->purpose;
5819                       break;
5820                     }
5821                 }
5822             }
5823         }
5824     }
5825
5826   /* Ordinarily return, but not if we want to output all
5827      and there are elements left.  */
5828   if (! (all && next != 0))
5829     return;
5830
5831   /* If it's not incremental, just skip over the gap, so that after
5832      jumping to retry we will output the next successive element.  */
5833   if (TREE_CODE (constructor_type) == RECORD_TYPE
5834       || TREE_CODE (constructor_type) == UNION_TYPE)
5835     constructor_unfilled_fields = next;
5836   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5837     constructor_unfilled_index = next;
5838
5839   /* ELT now points to the node in the pending tree with the next
5840      initializer to output.  */
5841   goto retry;
5842 }
5843 \f
5844 /* Add one non-braced element to the current constructor level.
5845    This adjusts the current position within the constructor's type.
5846    This may also start or terminate implicit levels
5847    to handle a partly-braced initializer.
5848
5849    Once this has found the correct level for the new element,
5850    it calls output_init_element.  */
5851
5852 void
5853 process_init_element (struct c_expr value)
5854 {
5855   tree orig_value = value.value;
5856   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
5857   bool strict_string = value.original_code == STRING_CST;
5858
5859   designator_depth = 0;
5860   designator_errorneous = 0;
5861
5862   /* Handle superfluous braces around string cst as in
5863      char x[] = {"foo"}; */
5864   if (string_flag
5865       && constructor_type
5866       && TREE_CODE (constructor_type) == ARRAY_TYPE
5867       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
5868       && integer_zerop (constructor_unfilled_index))
5869     {
5870       if (constructor_stack->replacement_value.value)
5871         error_init ("excess elements in char array initializer");
5872       constructor_stack->replacement_value = value;
5873       return;
5874     }
5875
5876   if (constructor_stack->replacement_value.value != 0)
5877     {
5878       error_init ("excess elements in struct initializer");
5879       return;
5880     }
5881
5882   /* Ignore elements of a brace group if it is entirely superfluous
5883      and has already been diagnosed.  */
5884   if (constructor_type == 0)
5885     return;
5886
5887   /* If we've exhausted any levels that didn't have braces,
5888      pop them now.  */
5889   while (constructor_stack->implicit)
5890     {
5891       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5892            || TREE_CODE (constructor_type) == UNION_TYPE)
5893           && constructor_fields == 0)
5894         process_init_element (pop_init_level (1));
5895       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5896                && (constructor_max_index == 0
5897                    || tree_int_cst_lt (constructor_max_index,
5898                                        constructor_index)))
5899         process_init_element (pop_init_level (1));
5900       else
5901         break;
5902     }
5903
5904   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
5905   if (constructor_range_stack)
5906     {
5907       /* If value is a compound literal and we'll be just using its
5908          content, don't put it into a SAVE_EXPR.  */
5909       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
5910           || !require_constant_value
5911           || flag_isoc99)
5912         value.value = save_expr (value.value);
5913     }
5914
5915   while (1)
5916     {
5917       if (TREE_CODE (constructor_type) == RECORD_TYPE)
5918         {
5919           tree fieldtype;
5920           enum tree_code fieldcode;
5921
5922           if (constructor_fields == 0)
5923             {
5924               pedwarn_init ("excess elements in struct initializer");
5925               break;
5926             }
5927
5928           fieldtype = TREE_TYPE (constructor_fields);
5929           if (fieldtype != error_mark_node)
5930             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5931           fieldcode = TREE_CODE (fieldtype);
5932
5933           /* Error for non-static initialization of a flexible array member.  */
5934           if (fieldcode == ARRAY_TYPE
5935               && !require_constant_value
5936               && TYPE_SIZE (fieldtype) == NULL_TREE
5937               && TREE_CHAIN (constructor_fields) == NULL_TREE)
5938             {
5939               error_init ("non-static initialization of a flexible array member");
5940               break;
5941             }
5942
5943           /* Accept a string constant to initialize a subarray.  */
5944           if (value.value != 0
5945               && fieldcode == ARRAY_TYPE
5946               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
5947               && string_flag)
5948             value.value = orig_value;
5949           /* Otherwise, if we have come to a subaggregate,
5950              and we don't have an element of its type, push into it.  */
5951           else if (value.value != 0 && !constructor_no_implicit
5952                    && value.value != error_mark_node
5953                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
5954                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5955                        || fieldcode == UNION_TYPE))
5956             {
5957               push_init_level (1);
5958               continue;
5959             }
5960
5961           if (value.value)
5962             {
5963               push_member_name (constructor_fields);
5964               output_init_element (value.value, strict_string,
5965                                    fieldtype, constructor_fields, 1);
5966               RESTORE_SPELLING_DEPTH (constructor_depth);
5967             }
5968           else
5969             /* Do the bookkeeping for an element that was
5970                directly output as a constructor.  */
5971             {
5972               /* For a record, keep track of end position of last field.  */
5973               if (DECL_SIZE (constructor_fields))
5974                 constructor_bit_index
5975                   = size_binop (PLUS_EXPR,
5976                                 bit_position (constructor_fields),
5977                                 DECL_SIZE (constructor_fields));
5978
5979               /* If the current field was the first one not yet written out,
5980                  it isn't now, so update.  */
5981               if (constructor_unfilled_fields == constructor_fields)
5982                 {
5983                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5984                   /* Skip any nameless bit fields.  */
5985                   while (constructor_unfilled_fields != 0
5986                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5987                          && DECL_NAME (constructor_unfilled_fields) == 0)
5988                     constructor_unfilled_fields =
5989                       TREE_CHAIN (constructor_unfilled_fields);
5990                 }
5991             }
5992
5993           constructor_fields = TREE_CHAIN (constructor_fields);
5994           /* Skip any nameless bit fields at the beginning.  */
5995           while (constructor_fields != 0
5996                  && DECL_C_BIT_FIELD (constructor_fields)
5997                  && DECL_NAME (constructor_fields) == 0)
5998             constructor_fields = TREE_CHAIN (constructor_fields);
5999         }
6000       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6001         {
6002           tree fieldtype;
6003           enum tree_code fieldcode;
6004
6005           if (constructor_fields == 0)
6006             {
6007               pedwarn_init ("excess elements in union initializer");
6008               break;
6009             }
6010
6011           fieldtype = TREE_TYPE (constructor_fields);
6012           if (fieldtype != error_mark_node)
6013             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6014           fieldcode = TREE_CODE (fieldtype);
6015
6016           /* Warn that traditional C rejects initialization of unions.
6017              We skip the warning if the value is zero.  This is done
6018              under the assumption that the zero initializer in user
6019              code appears conditioned on e.g. __STDC__ to avoid
6020              "missing initializer" warnings and relies on default
6021              initialization to zero in the traditional C case.
6022              We also skip the warning if the initializer is designated,
6023              again on the assumption that this must be conditional on
6024              __STDC__ anyway (and we've already complained about the
6025              member-designator already).  */
6026           if (warn_traditional && !in_system_header && !constructor_designated
6027               && !(value.value && (integer_zerop (value.value)
6028                                    || real_zerop (value.value))))
6029             warning ("traditional C rejects initialization of unions");
6030
6031           /* Accept a string constant to initialize a subarray.  */
6032           if (value.value != 0
6033               && fieldcode == ARRAY_TYPE
6034               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6035               && string_flag)
6036             value.value = orig_value;
6037           /* Otherwise, if we have come to a subaggregate,
6038              and we don't have an element of its type, push into it.  */
6039           else if (value.value != 0 && !constructor_no_implicit
6040                    && value.value != error_mark_node
6041                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6042                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6043                        || fieldcode == UNION_TYPE))
6044             {
6045               push_init_level (1);
6046               continue;
6047             }
6048
6049           if (value.value)
6050             {
6051               push_member_name (constructor_fields);
6052               output_init_element (value.value, strict_string,
6053                                    fieldtype, constructor_fields, 1);
6054               RESTORE_SPELLING_DEPTH (constructor_depth);
6055             }
6056           else
6057             /* Do the bookkeeping for an element that was
6058                directly output as a constructor.  */
6059             {
6060               constructor_bit_index = DECL_SIZE (constructor_fields);
6061               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6062             }
6063
6064           constructor_fields = 0;
6065         }
6066       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6067         {
6068           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6069           enum tree_code eltcode = TREE_CODE (elttype);
6070
6071           /* Accept a string constant to initialize a subarray.  */
6072           if (value.value != 0
6073               && eltcode == ARRAY_TYPE
6074               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
6075               && string_flag)
6076             value.value = orig_value;
6077           /* Otherwise, if we have come to a subaggregate,
6078              and we don't have an element of its type, push into it.  */
6079           else if (value.value != 0 && !constructor_no_implicit
6080                    && value.value != error_mark_node
6081                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
6082                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6083                        || eltcode == UNION_TYPE))
6084             {
6085               push_init_level (1);
6086               continue;
6087             }
6088
6089           if (constructor_max_index != 0
6090               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6091                   || integer_all_onesp (constructor_max_index)))
6092             {
6093               pedwarn_init ("excess elements in array initializer");
6094               break;
6095             }
6096
6097           /* Now output the actual element.  */
6098           if (value.value)
6099             {
6100               push_array_bounds (tree_low_cst (constructor_index, 0));
6101               output_init_element (value.value, strict_string,
6102                                    elttype, constructor_index, 1);
6103               RESTORE_SPELLING_DEPTH (constructor_depth);
6104             }
6105
6106           constructor_index
6107             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6108
6109           if (!value.value)
6110             /* If we are doing the bookkeeping for an element that was
6111                directly output as a constructor, we must update
6112                constructor_unfilled_index.  */
6113             constructor_unfilled_index = constructor_index;
6114         }
6115       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6116         {
6117           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6118
6119          /* Do a basic check of initializer size.  Note that vectors
6120             always have a fixed size derived from their type.  */
6121           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6122             {
6123               pedwarn_init ("excess elements in vector initializer");
6124               break;
6125             }
6126
6127           /* Now output the actual element.  */
6128           if (value.value)
6129             output_init_element (value.value, strict_string,
6130                                  elttype, constructor_index, 1);
6131
6132           constructor_index
6133             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6134
6135           if (!value.value)
6136             /* If we are doing the bookkeeping for an element that was
6137                directly output as a constructor, we must update
6138                constructor_unfilled_index.  */
6139             constructor_unfilled_index = constructor_index;
6140         }
6141
6142       /* Handle the sole element allowed in a braced initializer
6143          for a scalar variable.  */
6144       else if (constructor_fields == 0)
6145         {
6146           pedwarn_init ("excess elements in scalar initializer");
6147           break;
6148         }
6149       else
6150         {
6151           if (value.value)
6152             output_init_element (value.value, strict_string,
6153                                  constructor_type, NULL_TREE, 1);
6154           constructor_fields = 0;
6155         }
6156
6157       /* Handle range initializers either at this level or anywhere higher
6158          in the designator stack.  */
6159       if (constructor_range_stack)
6160         {
6161           struct constructor_range_stack *p, *range_stack;
6162           int finish = 0;
6163
6164           range_stack = constructor_range_stack;
6165           constructor_range_stack = 0;
6166           while (constructor_stack != range_stack->stack)
6167             {
6168               gcc_assert (constructor_stack->implicit);
6169               process_init_element (pop_init_level (1));
6170             }
6171           for (p = range_stack;
6172                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6173                p = p->prev)
6174             {
6175               gcc_assert (constructor_stack->implicit);
6176               process_init_element (pop_init_level (1));
6177             }
6178
6179           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6180           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6181             finish = 1;
6182
6183           while (1)
6184             {
6185               constructor_index = p->index;
6186               constructor_fields = p->fields;
6187               if (finish && p->range_end && p->index == p->range_start)
6188                 {
6189                   finish = 0;
6190                   p->prev = 0;
6191                 }
6192               p = p->next;
6193               if (!p)
6194                 break;
6195               push_init_level (2);
6196               p->stack = constructor_stack;
6197               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6198                 p->index = p->range_start;
6199             }
6200
6201           if (!finish)
6202             constructor_range_stack = range_stack;
6203           continue;
6204         }
6205
6206       break;
6207     }
6208
6209   constructor_range_stack = 0;
6210 }
6211 \f
6212 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6213    (guaranteed to be 'volatile' or null) and ARGS (represented using
6214    an ASM_EXPR node).  */
6215 tree
6216 build_asm_stmt (tree cv_qualifier, tree args)
6217 {
6218   if (!ASM_VOLATILE_P (args) && cv_qualifier)
6219     ASM_VOLATILE_P (args) = 1;
6220   return add_stmt (args);
6221 }
6222
6223 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6224    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
6225    SIMPLE indicates whether there was anything at all after the
6226    string in the asm expression -- asm("blah") and asm("blah" : )
6227    are subtly different.  We use a ASM_EXPR node to represent this.  */
6228 tree
6229 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6230                 bool simple)
6231 {
6232   tree tail;
6233   tree args;
6234   int i;
6235   const char *constraint;
6236   bool allows_mem, allows_reg, is_inout;
6237   int ninputs;
6238   int noutputs;
6239
6240   ninputs = list_length (inputs);
6241   noutputs = list_length (outputs);
6242
6243   /* Remove output conversions that change the type but not the mode.  */
6244   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
6245     {
6246       tree output = TREE_VALUE (tail);
6247       STRIP_NOPS (output);
6248       TREE_VALUE (tail) = output;
6249       lvalue_or_else (output, "invalid lvalue in asm statement");
6250
6251       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6252
6253       if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
6254                                     &allows_mem, &allows_reg, &is_inout))
6255         {
6256           /* By marking this operand as erroneous, we will not try
6257           to process this operand again in expand_asm_operands.  */
6258           TREE_VALUE (tail) = error_mark_node;
6259           continue;
6260         }
6261
6262       /* If the operand is a DECL that is going to end up in
6263         memory, assume it is addressable.  This is a bit more
6264         conservative than it would ideally be; the exact test is
6265         buried deep in expand_asm_operands and depends on the
6266         DECL_RTL for the OPERAND -- which we don't have at this
6267         point.  */
6268       if (!allows_reg && DECL_P (output))
6269         c_mark_addressable (output);
6270     }
6271
6272   /* Perform default conversions on array and function inputs.
6273      Don't do this for other types as it would screw up operands
6274      expected to be in memory.  */
6275   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6276     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6277
6278   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
6279
6280   /* Simple asm statements are treated as volatile.  */
6281   if (simple)
6282     {
6283       ASM_VOLATILE_P (args) = 1;
6284       ASM_INPUT_P (args) = 1;
6285     }
6286   return args;
6287 }
6288 \f
6289 /* Generate a goto statement to LABEL.  */
6290
6291 tree
6292 c_finish_goto_label (tree label)
6293 {
6294   tree decl = lookup_label (label);
6295   if (!decl)
6296     return NULL_TREE;
6297
6298   TREE_USED (decl) = 1;
6299   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
6300 }
6301
6302 /* Generate a computed goto statement to EXPR.  */
6303
6304 tree
6305 c_finish_goto_ptr (tree expr)
6306 {
6307   if (pedantic)
6308     pedwarn ("ISO C forbids `goto *expr;'");
6309   expr = convert (ptr_type_node, expr);
6310   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
6311 }
6312
6313 /* Generate a C `return' statement.  RETVAL is the expression for what
6314    to return, or a null pointer for `return;' with no value.  */
6315
6316 tree
6317 c_finish_return (tree retval)
6318 {
6319   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6320
6321   if (TREE_THIS_VOLATILE (current_function_decl))
6322     warning ("function declared `noreturn' has a `return' statement");
6323
6324   if (!retval)
6325     {
6326       current_function_returns_null = 1;
6327       if ((warn_return_type || flag_isoc99)
6328           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6329         pedwarn_c99 ("`return' with no value, in function returning non-void");
6330     }
6331   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6332     {
6333       current_function_returns_null = 1;
6334       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6335         pedwarn ("`return' with a value, in function returning void");
6336     }
6337   else
6338     {
6339       tree t = convert_for_assignment (valtype, retval, _("return"),
6340                                        NULL_TREE, NULL_TREE, 0);
6341       tree res = DECL_RESULT (current_function_decl);
6342       tree inner;
6343
6344       current_function_returns_value = 1;
6345       if (t == error_mark_node)
6346         return NULL_TREE;
6347
6348       inner = t = convert (TREE_TYPE (res), t);
6349
6350       /* Strip any conversions, additions, and subtractions, and see if
6351          we are returning the address of a local variable.  Warn if so.  */
6352       while (1)
6353         {
6354           switch (TREE_CODE (inner))
6355             {
6356             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6357             case PLUS_EXPR:
6358               inner = TREE_OPERAND (inner, 0);
6359               continue;
6360
6361             case MINUS_EXPR:
6362               /* If the second operand of the MINUS_EXPR has a pointer
6363                  type (or is converted from it), this may be valid, so
6364                  don't give a warning.  */
6365               {
6366                 tree op1 = TREE_OPERAND (inner, 1);
6367
6368                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6369                        && (TREE_CODE (op1) == NOP_EXPR
6370                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6371                            || TREE_CODE (op1) == CONVERT_EXPR))
6372                   op1 = TREE_OPERAND (op1, 0);
6373
6374                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6375                   break;
6376
6377                 inner = TREE_OPERAND (inner, 0);
6378                 continue;
6379               }
6380
6381             case ADDR_EXPR:
6382               inner = TREE_OPERAND (inner, 0);
6383
6384               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r'
6385                      && TREE_CODE (inner) != INDIRECT_REF)
6386                 inner = TREE_OPERAND (inner, 0);
6387
6388               if (DECL_P (inner)
6389                   && ! DECL_EXTERNAL (inner)
6390                   && ! TREE_STATIC (inner)
6391                   && DECL_CONTEXT (inner) == current_function_decl)
6392                 warning ("function returns address of local variable");
6393               break;
6394
6395             default:
6396               break;
6397             }
6398
6399           break;
6400         }
6401
6402       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
6403     }
6404
6405   return add_stmt (build_stmt (RETURN_EXPR, retval));
6406 }
6407 \f
6408 struct c_switch {
6409   /* The SWITCH_STMT being built.  */
6410   tree switch_stmt;
6411
6412   /* The original type of the testing expression, i.e. before the
6413      default conversion is applied.  */
6414   tree orig_type;
6415
6416   /* A splay-tree mapping the low element of a case range to the high
6417      element, or NULL_TREE if there is no high element.  Used to
6418      determine whether or not a new case label duplicates an old case
6419      label.  We need a tree, rather than simply a hash table, because
6420      of the GNU case range extension.  */
6421   splay_tree cases;
6422
6423   /* The next node on the stack.  */
6424   struct c_switch *next;
6425 };
6426
6427 /* A stack of the currently active switch statements.  The innermost
6428    switch statement is on the top of the stack.  There is no need to
6429    mark the stack for garbage collection because it is only active
6430    during the processing of the body of a function, and we never
6431    collect at that point.  */
6432
6433 struct c_switch *c_switch_stack;
6434
6435 /* Start a C switch statement, testing expression EXP.  Return the new
6436    SWITCH_STMT.  */
6437
6438 tree
6439 c_start_case (tree exp)
6440 {
6441   enum tree_code code;
6442   tree type, orig_type = error_mark_node;
6443   struct c_switch *cs;
6444
6445   if (exp != error_mark_node)
6446     {
6447       code = TREE_CODE (TREE_TYPE (exp));
6448       orig_type = TREE_TYPE (exp);
6449
6450       if (! INTEGRAL_TYPE_P (orig_type)
6451           && code != ERROR_MARK)
6452         {
6453           error ("switch quantity not an integer");
6454           exp = integer_zero_node;
6455         }
6456       else
6457         {
6458           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6459
6460           if (warn_traditional && !in_system_header
6461               && (type == long_integer_type_node
6462                   || type == long_unsigned_type_node))
6463             warning ("`long' switch expression not converted to `int' in ISO C");
6464
6465           exp = default_conversion (exp);
6466           type = TREE_TYPE (exp);
6467         }
6468     }
6469
6470   /* Add this new SWITCH_STMT to the stack.  */
6471   cs = XNEW (struct c_switch);
6472   cs->switch_stmt = build_stmt ((enum tree_code) SWITCH_STMT, exp, NULL_TREE,
6473                                 orig_type);
6474   cs->orig_type = orig_type;
6475   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6476   cs->next = c_switch_stack;
6477   c_switch_stack = cs;
6478
6479   return add_stmt (cs->switch_stmt);
6480 }
6481
6482 /* Process a case label.  */
6483
6484 tree
6485 do_case (tree low_value, tree high_value)
6486 {
6487   tree label = NULL_TREE;
6488
6489   if (c_switch_stack)
6490     {
6491       label = c_add_case_label (c_switch_stack->cases,
6492                                 SWITCH_COND (c_switch_stack->switch_stmt),
6493                                 c_switch_stack->orig_type,
6494                                 low_value, high_value);
6495       if (label == error_mark_node)
6496         label = NULL_TREE;
6497     }
6498   else if (low_value)
6499     error ("case label not within a switch statement");
6500   else
6501     error ("`default' label not within a switch statement");
6502
6503   return label;
6504 }
6505
6506 /* Finish the switch statement.  */
6507
6508 void
6509 c_finish_case (tree body)
6510 {
6511   struct c_switch *cs = c_switch_stack;
6512
6513   SWITCH_BODY (cs->switch_stmt) = body;
6514
6515   /* Emit warnings as needed.  */
6516   c_do_switch_warnings (cs->cases, cs->switch_stmt);
6517
6518   /* Pop the stack.  */
6519   c_switch_stack = cs->next;
6520   splay_tree_delete (cs->cases);
6521   XDELETE (cs);
6522 }
6523 \f
6524 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
6525    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6526    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
6527    statement, and was not surrounded with parenthesis.  */
6528
6529 void
6530 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
6531                   tree else_block, bool nested_if)
6532 {
6533   tree stmt;
6534
6535   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
6536   if (warn_parentheses && nested_if && else_block == NULL)
6537     {
6538       tree inner_if = then_block;
6539
6540       /* We know from the grammar productions that there is an IF nested
6541          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
6542          it might not be exactly THEN_BLOCK, but should be the last
6543          non-container statement within.  */
6544       while (1)
6545         switch (TREE_CODE (inner_if))
6546           {
6547           case COND_EXPR:
6548             goto found;
6549           case BIND_EXPR:
6550             inner_if = BIND_EXPR_BODY (inner_if);
6551             break;
6552           case STATEMENT_LIST:
6553             inner_if = expr_last (then_block);
6554             break;
6555           case TRY_FINALLY_EXPR:
6556           case TRY_CATCH_EXPR:
6557             inner_if = TREE_OPERAND (inner_if, 0);
6558             break;
6559           default:
6560             gcc_unreachable ();
6561           }
6562     found:
6563
6564       if (COND_EXPR_ELSE (inner_if))
6565          warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
6566                   &if_locus);
6567     }
6568
6569   /* Diagnose ";" via the special empty statement node that we create.  */
6570   if (extra_warnings)
6571     {
6572       if (TREE_CODE (then_block) == NOP_EXPR && !TREE_TYPE (then_block))
6573         {
6574           if (!else_block)
6575             warning ("%Hempty body in an if-statement",
6576                      EXPR_LOCUS (then_block));
6577           then_block = alloc_stmt_list ();
6578         }
6579       if (else_block
6580           && TREE_CODE (else_block) == NOP_EXPR
6581           && !TREE_TYPE (else_block))
6582         {
6583           warning ("%Hempty body in an else-statement",
6584                    EXPR_LOCUS (else_block));
6585           else_block = alloc_stmt_list ();
6586         }
6587     }
6588
6589   stmt = build3 (COND_EXPR, NULL_TREE, cond, then_block, else_block);
6590   SET_EXPR_LOCATION (stmt, if_locus);
6591   add_stmt (stmt);
6592 }
6593
6594 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
6595    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
6596    is false for DO loops.  INCR is the FOR increment expression.  BODY is
6597    the statement controlled by the loop.  BLAB is the break label.  CLAB is
6598    the continue label.  Everything is allowed to be NULL.  */
6599
6600 void
6601 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
6602                tree blab, tree clab, bool cond_is_first)
6603 {
6604   tree entry = NULL, exit = NULL, t;
6605
6606   /* Detect do { ... } while (0) and don't generate loop construct.  */
6607   if (cond && !cond_is_first && integer_zerop (cond))
6608     cond = NULL;
6609   if (cond_is_first || cond)
6610     {
6611       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6612
6613       /* If we have an exit condition, then we build an IF with gotos either
6614          out of the loop, or to the top of it.  If there's no exit condition,
6615          then we just build a jump back to the top.  */
6616       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
6617
6618       if (cond)
6619         {
6620           /* Canonicalize the loop condition to the end.  This means
6621              generating a branch to the loop condition.  Reuse the
6622              continue label, if possible.  */
6623           if (cond_is_first)
6624             {
6625               if (incr || !clab)
6626                 {
6627                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6628                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
6629                 }
6630               else
6631                 t = build1 (GOTO_EXPR, void_type_node, clab);
6632               SET_EXPR_LOCATION (t, start_locus);
6633               add_stmt (t);
6634             }
6635
6636           t = build_and_jump (&blab);
6637           exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
6638           exit = fold (exit);
6639           if (cond_is_first)
6640             SET_EXPR_LOCATION (exit, start_locus);
6641           else
6642             SET_EXPR_LOCATION (exit, input_location);
6643         }
6644
6645       add_stmt (top);
6646     }
6647
6648   if (body)
6649     add_stmt (body);
6650   if (clab)
6651     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
6652   if (incr)
6653     add_stmt (incr);
6654   if (entry)
6655     add_stmt (entry);
6656   if (exit)
6657     add_stmt (exit);
6658   if (blab)
6659     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
6660 }
6661
6662 tree
6663 c_finish_bc_stmt (tree *label_p, bool is_break)
6664 {
6665   tree label = *label_p;
6666
6667   if (!label)
6668     *label_p = label = create_artificial_label ();
6669   else if (TREE_CODE (label) != LABEL_DECL)
6670     {
6671       if (is_break)
6672         error ("break statement not within loop or switch");
6673       else
6674         error ("continue statement not within a loop");
6675       return NULL_TREE;
6676     }
6677
6678   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
6679 }
6680
6681 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
6682
6683 static void
6684 emit_side_effect_warnings (tree expr)
6685 {
6686   if (expr == error_mark_node)
6687     ;
6688   else if (!TREE_SIDE_EFFECTS (expr))
6689     {
6690       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
6691         warning ("%Hstatement with no effect",
6692                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
6693     }
6694   else if (warn_unused_value)
6695     warn_if_unused_value (expr, input_location);
6696 }
6697
6698 /* Process an expression as if it were a complete statement.  Emit
6699    diagnostics, but do not call ADD_STMT.  */
6700
6701 tree
6702 c_process_expr_stmt (tree expr)
6703 {
6704   if (!expr)
6705     return NULL_TREE;
6706
6707   /* Do default conversion if safe and possibly important,
6708      in case within ({...}).  */
6709   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
6710        && (flag_isoc99 || lvalue_p (expr)))
6711       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
6712     expr = default_conversion (expr);
6713
6714   if (warn_sequence_point)
6715     verify_sequence_points (expr);
6716
6717   if (TREE_TYPE (expr) != error_mark_node
6718       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
6719       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
6720     error ("expression statement has incomplete type");
6721
6722   /* If we're not processing a statement expression, warn about unused values.
6723      Warnings for statement expressions will be emitted later, once we figure
6724      out which is the result.  */
6725   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6726       && (extra_warnings || warn_unused_value))
6727     emit_side_effect_warnings (expr);
6728
6729   /* If the expression is not of a type to which we cannot assign a line
6730      number, wrap the thing in a no-op NOP_EXPR.  */
6731   if (DECL_P (expr) || TREE_CODE_CLASS (TREE_CODE (expr)) == 'c')
6732     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
6733
6734   if (EXPR_P (expr))
6735     SET_EXPR_LOCATION (expr, input_location);
6736
6737   return expr;
6738 }
6739
6740 /* Emit an expression as a statement.  */
6741
6742 tree
6743 c_finish_expr_stmt (tree expr)
6744 {
6745   if (expr)
6746     return add_stmt (c_process_expr_stmt (expr));
6747   else
6748     return NULL;
6749 }
6750
6751 /* Do the opposite and emit a statement as an expression.  To begin,
6752    create a new binding level and return it.  */
6753
6754 tree
6755 c_begin_stmt_expr (void)
6756 {
6757   tree ret;
6758
6759   /* We must force a BLOCK for this level so that, if it is not expanded
6760      later, there is a way to turn off the entire subtree of blocks that
6761      are contained in it.  */
6762   keep_next_level ();
6763   ret = c_begin_compound_stmt (true);
6764
6765   /* Mark the current statement list as belonging to a statement list.  */
6766   STATEMENT_LIST_STMT_EXPR (ret) = 1;
6767
6768   return ret;
6769 }
6770
6771 tree
6772 c_finish_stmt_expr (tree body)
6773 {
6774   tree last, type, tmp, val;
6775   tree *last_p;
6776
6777   body = c_end_compound_stmt (body, true);
6778
6779   /* Locate the last statement in BODY.  See c_end_compound_stmt
6780      about always returning a BIND_EXPR.  */
6781   last_p = &BIND_EXPR_BODY (body);
6782   last = BIND_EXPR_BODY (body);
6783
6784  continue_searching:
6785   if (TREE_CODE (last) == STATEMENT_LIST)
6786     {
6787       tree_stmt_iterator i;
6788
6789       /* This can happen with degenerate cases like ({ }).  No value.  */
6790       if (!TREE_SIDE_EFFECTS (last))
6791         return body;
6792
6793       /* If we're supposed to generate side effects warnings, process
6794          all of the statements except the last.  */
6795       if (extra_warnings || warn_unused_value)
6796         {
6797           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
6798             emit_side_effect_warnings (tsi_stmt (i));
6799         }
6800       else
6801         i = tsi_last (last);
6802       last_p = tsi_stmt_ptr (i);
6803       last = *last_p;
6804     }
6805
6806   /* If the end of the list is exception related, then the list was split
6807      by a call to push_cleanup.  Continue searching.  */
6808   if (TREE_CODE (last) == TRY_FINALLY_EXPR
6809       || TREE_CODE (last) == TRY_CATCH_EXPR)
6810     {
6811       last_p = &TREE_OPERAND (last, 0);
6812       last = *last_p;
6813       goto continue_searching;
6814     }
6815
6816   /* In the case that the BIND_EXPR is not necessary, return the
6817      expression out from inside it.  */
6818   if (last == error_mark_node
6819       || (last == BIND_EXPR_BODY (body)
6820           && BIND_EXPR_VARS (body) == NULL))
6821     return last;
6822
6823   /* Extract the type of said expression.  */
6824   type = TREE_TYPE (last);
6825
6826   /* If we're not returning a value at all, then the BIND_EXPR that
6827      we already have is a fine expression to return.  */
6828   if (!type || VOID_TYPE_P (type))
6829     return body;
6830
6831   /* Now that we've located the expression containing the value, it seems
6832      silly to make voidify_wrapper_expr repeat the process.  Create a
6833      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
6834   tmp = create_tmp_var_raw (type, NULL);
6835
6836   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
6837      tree_expr_nonnegative_p giving up immediately.  */
6838   val = last;
6839   if (TREE_CODE (val) == NOP_EXPR
6840       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
6841     val = TREE_OPERAND (val, 0);
6842
6843   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
6844   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
6845
6846   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
6847 }
6848 \f
6849 /* Begin and end compound statements.  This is as simple as pushing
6850    and popping new statement lists from the tree.  */
6851
6852 tree
6853 c_begin_compound_stmt (bool do_scope)
6854 {
6855   tree stmt = push_stmt_list ();
6856   if (do_scope)
6857     push_scope ();
6858   return stmt;
6859 }
6860
6861 tree
6862 c_end_compound_stmt (tree stmt, bool do_scope)
6863 {
6864   tree block = NULL;
6865
6866   if (do_scope)
6867     {
6868       if (c_dialect_objc ())
6869         objc_clear_super_receiver ();
6870       block = pop_scope ();
6871     }
6872
6873   stmt = pop_stmt_list (stmt);
6874   stmt = c_build_bind_expr (block, stmt);
6875
6876   /* If this compound statement is nested immediately inside a statement
6877      expression, then force a BIND_EXPR to be created.  Otherwise we'll
6878      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
6879      STATEMENT_LISTs merge, and thus we can lose track of what statement
6880      was really last.  */
6881   if (cur_stmt_list
6882       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6883       && TREE_CODE (stmt) != BIND_EXPR)
6884     {
6885       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
6886       TREE_SIDE_EFFECTS (stmt) = 1;
6887     }
6888
6889   return stmt;
6890 }
6891
6892 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
6893    when the current scope is exited.  EH_ONLY is true when this is not
6894    meant to apply to normal control flow transfer.  */
6895
6896 void
6897 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
6898 {
6899   enum tree_code code;
6900   tree stmt, list;
6901   bool stmt_expr;
6902
6903   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
6904   stmt = build_stmt (code, NULL, cleanup);
6905   add_stmt (stmt);
6906   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
6907   list = push_stmt_list ();
6908   TREE_OPERAND (stmt, 0) = list;
6909   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
6910 }
6911 \f
6912 /* Build a binary-operation expression without default conversions.
6913    CODE is the kind of expression to build.
6914    This function differs from `build' in several ways:
6915    the data type of the result is computed and recorded in it,
6916    warnings are generated if arg data types are invalid,
6917    special handling for addition and subtraction of pointers is known,
6918    and some optimization is done (operations on narrow ints
6919    are done in the narrower type when that gives the same result).
6920    Constant folding is also done before the result is returned.
6921
6922    Note that the operands will never have enumeral types, or function
6923    or array types, because either they will have the default conversions
6924    performed or they have both just been converted to some other type in which
6925    the arithmetic is to be done.  */
6926
6927 tree
6928 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6929                  int convert_p)
6930 {
6931   tree type0, type1;
6932   enum tree_code code0, code1;
6933   tree op0, op1;
6934
6935   /* Expression code to give to the expression when it is built.
6936      Normally this is CODE, which is what the caller asked for,
6937      but in some special cases we change it.  */
6938   enum tree_code resultcode = code;
6939
6940   /* Data type in which the computation is to be performed.
6941      In the simplest cases this is the common type of the arguments.  */
6942   tree result_type = NULL;
6943
6944   /* Nonzero means operands have already been type-converted
6945      in whatever way is necessary.
6946      Zero means they need to be converted to RESULT_TYPE.  */
6947   int converted = 0;
6948
6949   /* Nonzero means create the expression with this type, rather than
6950      RESULT_TYPE.  */
6951   tree build_type = 0;
6952
6953   /* Nonzero means after finally constructing the expression
6954      convert it to this type.  */
6955   tree final_type = 0;
6956
6957   /* Nonzero if this is an operation like MIN or MAX which can
6958      safely be computed in short if both args are promoted shorts.
6959      Also implies COMMON.
6960      -1 indicates a bitwise operation; this makes a difference
6961      in the exact conditions for when it is safe to do the operation
6962      in a narrower mode.  */
6963   int shorten = 0;
6964
6965   /* Nonzero if this is a comparison operation;
6966      if both args are promoted shorts, compare the original shorts.
6967      Also implies COMMON.  */
6968   int short_compare = 0;
6969
6970   /* Nonzero if this is a right-shift operation, which can be computed on the
6971      original short and then promoted if the operand is a promoted short.  */
6972   int short_shift = 0;
6973
6974   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
6975   int common = 0;
6976
6977   if (convert_p)
6978     {
6979       op0 = default_conversion (orig_op0);
6980       op1 = default_conversion (orig_op1);
6981     }
6982   else
6983     {
6984       op0 = orig_op0;
6985       op1 = orig_op1;
6986     }
6987
6988   type0 = TREE_TYPE (op0);
6989   type1 = TREE_TYPE (op1);
6990
6991   /* The expression codes of the data types of the arguments tell us
6992      whether the arguments are integers, floating, pointers, etc.  */
6993   code0 = TREE_CODE (type0);
6994   code1 = TREE_CODE (type1);
6995
6996   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
6997   STRIP_TYPE_NOPS (op0);
6998   STRIP_TYPE_NOPS (op1);
6999
7000   /* If an error was already reported for one of the arguments,
7001      avoid reporting another error.  */
7002
7003   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7004     return error_mark_node;
7005
7006   switch (code)
7007     {
7008     case PLUS_EXPR:
7009       /* Handle the pointer + int case.  */
7010       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7011         return pointer_int_sum (PLUS_EXPR, op0, op1);
7012       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
7013         return pointer_int_sum (PLUS_EXPR, op1, op0);
7014       else
7015         common = 1;
7016       break;
7017
7018     case MINUS_EXPR:
7019       /* Subtraction of two similar pointers.
7020          We must subtract them as integers, then divide by object size.  */
7021       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
7022           && comp_target_types (type0, type1, 1))
7023         return pointer_diff (op0, op1);
7024       /* Handle pointer minus int.  Just like pointer plus int.  */
7025       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7026         return pointer_int_sum (MINUS_EXPR, op0, op1);
7027       else
7028         common = 1;
7029       break;
7030
7031     case MULT_EXPR:
7032       common = 1;
7033       break;
7034
7035     case TRUNC_DIV_EXPR:
7036     case CEIL_DIV_EXPR:
7037     case FLOOR_DIV_EXPR:
7038     case ROUND_DIV_EXPR:
7039     case EXACT_DIV_EXPR:
7040       /* Floating point division by zero is a legitimate way to obtain
7041          infinities and NaNs.  */
7042       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
7043         warning ("division by zero");
7044
7045       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7046            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7047           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7048               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
7049         {
7050           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7051             code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
7052           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
7053             code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
7054
7055           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
7056             resultcode = RDIV_EXPR;
7057           else
7058             /* Although it would be tempting to shorten always here, that
7059                loses on some targets, since the modulo instruction is
7060                undefined if the quotient can't be represented in the
7061                computation mode.  We shorten only if unsigned or if
7062                dividing by something we know != -1.  */
7063             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7064                        || (TREE_CODE (op1) == INTEGER_CST
7065                            && ! integer_all_onesp (op1)));
7066           common = 1;
7067         }
7068       break;
7069
7070     case BIT_AND_EXPR:
7071     case BIT_IOR_EXPR:
7072     case BIT_XOR_EXPR:
7073       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7074         shorten = -1;
7075       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
7076         common = 1;
7077       break;
7078
7079     case TRUNC_MOD_EXPR:
7080     case FLOOR_MOD_EXPR:
7081       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
7082         warning ("division by zero");
7083
7084       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7085         {
7086           /* Although it would be tempting to shorten always here, that loses
7087              on some targets, since the modulo instruction is undefined if the
7088              quotient can't be represented in the computation mode.  We shorten
7089              only if unsigned or if dividing by something we know != -1.  */
7090           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7091                      || (TREE_CODE (op1) == INTEGER_CST
7092                          && ! integer_all_onesp (op1)));
7093           common = 1;
7094         }
7095       break;
7096
7097     case TRUTH_ANDIF_EXPR:
7098     case TRUTH_ORIF_EXPR:
7099     case TRUTH_AND_EXPR:
7100     case TRUTH_OR_EXPR:
7101     case TRUTH_XOR_EXPR:
7102       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
7103            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
7104           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
7105               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
7106         {
7107           /* Result of these operations is always an int,
7108              but that does not mean the operands should be
7109              converted to ints!  */
7110           result_type = integer_type_node;
7111           op0 = lang_hooks.truthvalue_conversion (op0);
7112           op1 = lang_hooks.truthvalue_conversion (op1);
7113           converted = 1;
7114         }
7115       break;
7116
7117       /* Shift operations: result has same type as first operand;
7118          always convert second operand to int.
7119          Also set SHORT_SHIFT if shifting rightward.  */
7120
7121     case RSHIFT_EXPR:
7122       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7123         {
7124           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7125             {
7126               if (tree_int_cst_sgn (op1) < 0)
7127                 warning ("right shift count is negative");
7128               else
7129                 {
7130                   if (! integer_zerop (op1))
7131                     short_shift = 1;
7132
7133                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7134                     warning ("right shift count >= width of type");
7135                 }
7136             }
7137
7138           /* Use the type of the value to be shifted.  */
7139           result_type = type0;
7140           /* Convert the shift-count to an integer, regardless of size
7141              of value being shifted.  */
7142           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7143             op1 = convert (integer_type_node, op1);
7144           /* Avoid converting op1 to result_type later.  */
7145           converted = 1;
7146         }
7147       break;
7148
7149     case LSHIFT_EXPR:
7150       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7151         {
7152           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7153             {
7154               if (tree_int_cst_sgn (op1) < 0)
7155                 warning ("left shift count is negative");
7156
7157               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7158                 warning ("left shift count >= width of type");
7159             }
7160
7161           /* Use the type of the value to be shifted.  */
7162           result_type = type0;
7163           /* Convert the shift-count to an integer, regardless of size
7164              of value being shifted.  */
7165           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7166             op1 = convert (integer_type_node, op1);
7167           /* Avoid converting op1 to result_type later.  */
7168           converted = 1;
7169         }
7170       break;
7171
7172     case RROTATE_EXPR:
7173     case LROTATE_EXPR:
7174       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7175         {
7176           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7177             {
7178               if (tree_int_cst_sgn (op1) < 0)
7179                 warning ("shift count is negative");
7180               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7181                 warning ("shift count >= width of type");
7182             }
7183
7184           /* Use the type of the value to be shifted.  */
7185           result_type = type0;
7186           /* Convert the shift-count to an integer, regardless of size
7187              of value being shifted.  */
7188           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7189             op1 = convert (integer_type_node, op1);
7190           /* Avoid converting op1 to result_type later.  */
7191           converted = 1;
7192         }
7193       break;
7194
7195     case EQ_EXPR:
7196     case NE_EXPR:
7197       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
7198         warning ("comparing floating point with == or != is unsafe");
7199       /* Result of comparison is always int,
7200          but don't convert the args to int!  */
7201       build_type = integer_type_node;
7202       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7203            || code0 == COMPLEX_TYPE)
7204           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7205               || code1 == COMPLEX_TYPE))
7206         short_compare = 1;
7207       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7208         {
7209           tree tt0 = TREE_TYPE (type0);
7210           tree tt1 = TREE_TYPE (type1);
7211           /* Anything compares with void *.  void * compares with anything.
7212              Otherwise, the targets must be compatible
7213              and both must be object or both incomplete.  */
7214           if (comp_target_types (type0, type1, 1))
7215             result_type = common_pointer_type (type0, type1);
7216           else if (VOID_TYPE_P (tt0))
7217             {
7218               /* op0 != orig_op0 detects the case of something
7219                  whose value is 0 but which isn't a valid null ptr const.  */
7220               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
7221                   && TREE_CODE (tt1) == FUNCTION_TYPE)
7222                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
7223             }
7224           else if (VOID_TYPE_P (tt1))
7225             {
7226               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
7227                   && TREE_CODE (tt0) == FUNCTION_TYPE)
7228                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
7229             }
7230           else
7231             pedwarn ("comparison of distinct pointer types lacks a cast");
7232
7233           if (result_type == NULL_TREE)
7234             result_type = ptr_type_node;
7235         }
7236       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7237                && integer_zerop (op1))
7238         result_type = type0;
7239       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7240                && integer_zerop (op0))
7241         result_type = type1;
7242       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7243         {
7244           result_type = type0;
7245           pedwarn ("comparison between pointer and integer");
7246         }
7247       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7248         {
7249           result_type = type1;
7250           pedwarn ("comparison between pointer and integer");
7251         }
7252       break;
7253
7254     case MAX_EXPR:
7255     case MIN_EXPR:
7256       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7257           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7258         shorten = 1;
7259       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7260         {
7261           if (comp_target_types (type0, type1, 1))
7262             {
7263               result_type = common_pointer_type (type0, type1);
7264               if (pedantic
7265                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7266                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7267             }
7268           else
7269             {
7270               result_type = ptr_type_node;
7271               pedwarn ("comparison of distinct pointer types lacks a cast");
7272             }
7273         }
7274       break;
7275
7276     case LE_EXPR:
7277     case GE_EXPR:
7278     case LT_EXPR:
7279     case GT_EXPR:
7280       build_type = integer_type_node;
7281       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7282           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7283         short_compare = 1;
7284       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7285         {
7286           if (comp_target_types (type0, type1, 1))
7287             {
7288               result_type = common_pointer_type (type0, type1);
7289               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
7290                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
7291                 pedwarn ("comparison of complete and incomplete pointers");
7292               else if (pedantic
7293                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7294                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7295             }
7296           else
7297             {
7298               result_type = ptr_type_node;
7299               pedwarn ("comparison of distinct pointer types lacks a cast");
7300             }
7301         }
7302       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7303                && integer_zerop (op1))
7304         {
7305           result_type = type0;
7306           if (pedantic || extra_warnings)
7307             pedwarn ("ordered comparison of pointer with integer zero");
7308         }
7309       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7310                && integer_zerop (op0))
7311         {
7312           result_type = type1;
7313           if (pedantic)
7314             pedwarn ("ordered comparison of pointer with integer zero");
7315         }
7316       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7317         {
7318           result_type = type0;
7319           pedwarn ("comparison between pointer and integer");
7320         }
7321       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7322         {
7323           result_type = type1;
7324           pedwarn ("comparison between pointer and integer");
7325         }
7326       break;
7327
7328     case UNORDERED_EXPR:
7329     case ORDERED_EXPR:
7330     case UNLT_EXPR:
7331     case UNLE_EXPR:
7332     case UNGT_EXPR:
7333     case UNGE_EXPR:
7334     case UNEQ_EXPR:
7335     case LTGT_EXPR:
7336       build_type = integer_type_node;
7337       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
7338         {
7339           error ("unordered comparison on non-floating point argument");
7340           return error_mark_node;
7341         }
7342       common = 1;
7343       break;
7344
7345     default:
7346       break;
7347     }
7348
7349   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7350     return error_mark_node;
7351
7352   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
7353        || code0 == VECTOR_TYPE)
7354       &&
7355       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
7356        || code1 == VECTOR_TYPE))
7357     {
7358       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7359
7360       if (shorten || common || short_compare)
7361         result_type = common_type (type0, type1);
7362
7363       /* For certain operations (which identify themselves by shorten != 0)
7364          if both args were extended from the same smaller type,
7365          do the arithmetic in that type and then extend.
7366
7367          shorten !=0 and !=1 indicates a bitwise operation.
7368          For them, this optimization is safe only if
7369          both args are zero-extended or both are sign-extended.
7370          Otherwise, we might change the result.
7371          Eg, (short)-1 | (unsigned short)-1 is (int)-1
7372          but calculated in (unsigned short) it would be (unsigned short)-1.  */
7373
7374       if (shorten && none_complex)
7375         {
7376           int unsigned0, unsigned1;
7377           tree arg0 = get_narrower (op0, &unsigned0);
7378           tree arg1 = get_narrower (op1, &unsigned1);
7379           /* UNS is 1 if the operation to be done is an unsigned one.  */
7380           int uns = TYPE_UNSIGNED (result_type);
7381           tree type;
7382
7383           final_type = result_type;
7384
7385           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7386              but it *requires* conversion to FINAL_TYPE.  */
7387
7388           if ((TYPE_PRECISION (TREE_TYPE (op0))
7389                == TYPE_PRECISION (TREE_TYPE (arg0)))
7390               && TREE_TYPE (op0) != final_type)
7391             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
7392           if ((TYPE_PRECISION (TREE_TYPE (op1))
7393                == TYPE_PRECISION (TREE_TYPE (arg1)))
7394               && TREE_TYPE (op1) != final_type)
7395             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
7396
7397           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
7398
7399           /* For bitwise operations, signedness of nominal type
7400              does not matter.  Consider only how operands were extended.  */
7401           if (shorten == -1)
7402             uns = unsigned0;
7403
7404           /* Note that in all three cases below we refrain from optimizing
7405              an unsigned operation on sign-extended args.
7406              That would not be valid.  */
7407
7408           /* Both args variable: if both extended in same way
7409              from same width, do it in that width.
7410              Do it unsigned if args were zero-extended.  */
7411           if ((TYPE_PRECISION (TREE_TYPE (arg0))
7412                < TYPE_PRECISION (result_type))
7413               && (TYPE_PRECISION (TREE_TYPE (arg1))
7414                   == TYPE_PRECISION (TREE_TYPE (arg0)))
7415               && unsigned0 == unsigned1
7416               && (unsigned0 || !uns))
7417             result_type
7418               = c_common_signed_or_unsigned_type
7419               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7420           else if (TREE_CODE (arg0) == INTEGER_CST
7421                    && (unsigned1 || !uns)
7422                    && (TYPE_PRECISION (TREE_TYPE (arg1))
7423                        < TYPE_PRECISION (result_type))
7424                    && (type
7425                        = c_common_signed_or_unsigned_type (unsigned1,
7426                                                            TREE_TYPE (arg1)),
7427                        int_fits_type_p (arg0, type)))
7428             result_type = type;
7429           else if (TREE_CODE (arg1) == INTEGER_CST
7430                    && (unsigned0 || !uns)
7431                    && (TYPE_PRECISION (TREE_TYPE (arg0))
7432                        < TYPE_PRECISION (result_type))
7433                    && (type
7434                        = c_common_signed_or_unsigned_type (unsigned0,
7435                                                            TREE_TYPE (arg0)),
7436                        int_fits_type_p (arg1, type)))
7437             result_type = type;
7438         }
7439
7440       /* Shifts can be shortened if shifting right.  */
7441
7442       if (short_shift)
7443         {
7444           int unsigned_arg;
7445           tree arg0 = get_narrower (op0, &unsigned_arg);
7446
7447           final_type = result_type;
7448
7449           if (arg0 == op0 && final_type == TREE_TYPE (op0))
7450             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
7451
7452           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7453               /* We can shorten only if the shift count is less than the
7454                  number of bits in the smaller type size.  */
7455               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7456               /* We cannot drop an unsigned shift after sign-extension.  */
7457               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
7458             {
7459               /* Do an unsigned shift if the operand was zero-extended.  */
7460               result_type
7461                 = c_common_signed_or_unsigned_type (unsigned_arg,
7462                                                     TREE_TYPE (arg0));
7463               /* Convert value-to-be-shifted to that type.  */
7464               if (TREE_TYPE (op0) != result_type)
7465                 op0 = convert (result_type, op0);
7466               converted = 1;
7467             }
7468         }
7469
7470       /* Comparison operations are shortened too but differently.
7471          They identify themselves by setting short_compare = 1.  */
7472
7473       if (short_compare)
7474         {
7475           /* Don't write &op0, etc., because that would prevent op0
7476              from being kept in a register.
7477              Instead, make copies of the our local variables and
7478              pass the copies by reference, then copy them back afterward.  */
7479           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7480           enum tree_code xresultcode = resultcode;
7481           tree val
7482             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7483
7484           if (val != 0)
7485             return val;
7486
7487           op0 = xop0, op1 = xop1;
7488           converted = 1;
7489           resultcode = xresultcode;
7490
7491           if (warn_sign_compare && skip_evaluation == 0)
7492             {
7493               int op0_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op0));
7494               int op1_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op1));
7495               int unsignedp0, unsignedp1;
7496               tree primop0 = get_narrower (op0, &unsignedp0);
7497               tree primop1 = get_narrower (op1, &unsignedp1);
7498
7499               xop0 = orig_op0;
7500               xop1 = orig_op1;
7501               STRIP_TYPE_NOPS (xop0);
7502               STRIP_TYPE_NOPS (xop1);
7503
7504               /* Give warnings for comparisons between signed and unsigned
7505                  quantities that may fail.
7506
7507                  Do the checking based on the original operand trees, so that
7508                  casts will be considered, but default promotions won't be.
7509
7510                  Do not warn if the comparison is being done in a signed type,
7511                  since the signed type will only be chosen if it can represent
7512                  all the values of the unsigned type.  */
7513               if (! TYPE_UNSIGNED (result_type))
7514                 /* OK */;
7515               /* Do not warn if both operands are the same signedness.  */
7516               else if (op0_signed == op1_signed)
7517                 /* OK */;
7518               else
7519                 {
7520                   tree sop, uop;
7521
7522                   if (op0_signed)
7523                     sop = xop0, uop = xop1;
7524                   else
7525                     sop = xop1, uop = xop0;
7526
7527                   /* Do not warn if the signed quantity is an
7528                      unsuffixed integer literal (or some static
7529                      constant expression involving such literals or a
7530                      conditional expression involving such literals)
7531                      and it is non-negative.  */
7532                   if (tree_expr_nonnegative_p (sop))
7533                     /* OK */;
7534                   /* Do not warn if the comparison is an equality operation,
7535                      the unsigned quantity is an integral constant, and it
7536                      would fit in the result if the result were signed.  */
7537                   else if (TREE_CODE (uop) == INTEGER_CST
7538                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7539                            && int_fits_type_p
7540                            (uop, c_common_signed_type (result_type)))
7541                     /* OK */;
7542                   /* Do not warn if the unsigned quantity is an enumeration
7543                      constant and its maximum value would fit in the result
7544                      if the result were signed.  */
7545                   else if (TREE_CODE (uop) == INTEGER_CST
7546                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7547                            && int_fits_type_p
7548                            (TYPE_MAX_VALUE (TREE_TYPE(uop)),
7549                             c_common_signed_type (result_type)))
7550                     /* OK */;
7551                   else
7552                     warning ("comparison between signed and unsigned");
7553                 }
7554
7555               /* Warn if two unsigned values are being compared in a size
7556                  larger than their original size, and one (and only one) is the
7557                  result of a `~' operator.  This comparison will always fail.
7558
7559                  Also warn if one operand is a constant, and the constant
7560                  does not have all bits set that are set in the ~ operand
7561                  when it is extended.  */
7562
7563               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7564                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7565                 {
7566                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7567                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7568                                             &unsignedp0);
7569                   else
7570                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7571                                             &unsignedp1);
7572
7573                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7574                     {
7575                       tree primop;
7576                       HOST_WIDE_INT constant, mask;
7577                       int unsignedp, bits;
7578
7579                       if (host_integerp (primop0, 0))
7580                         {
7581                           primop = primop1;
7582                           unsignedp = unsignedp1;
7583                           constant = tree_low_cst (primop0, 0);
7584                         }
7585                       else
7586                         {
7587                           primop = primop0;
7588                           unsignedp = unsignedp0;
7589                           constant = tree_low_cst (primop1, 0);
7590                         }
7591
7592                       bits = TYPE_PRECISION (TREE_TYPE (primop));
7593                       if (bits < TYPE_PRECISION (result_type)
7594                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7595                         {
7596                           mask = (~ (HOST_WIDE_INT) 0) << bits;
7597                           if ((mask & constant) != mask)
7598                             warning ("comparison of promoted ~unsigned with constant");
7599                         }
7600                     }
7601                   else if (unsignedp0 && unsignedp1
7602                            && (TYPE_PRECISION (TREE_TYPE (primop0))
7603                                < TYPE_PRECISION (result_type))
7604                            && (TYPE_PRECISION (TREE_TYPE (primop1))
7605                                < TYPE_PRECISION (result_type)))
7606                     warning ("comparison of promoted ~unsigned with unsigned");
7607                 }
7608             }
7609         }
7610     }
7611
7612   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7613      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7614      Then the expression will be built.
7615      It will be given type FINAL_TYPE if that is nonzero;
7616      otherwise, it will be given type RESULT_TYPE.  */
7617
7618   if (!result_type)
7619     {
7620       binary_op_error (code);
7621       return error_mark_node;
7622     }
7623
7624   if (! converted)
7625     {
7626       if (TREE_TYPE (op0) != result_type)
7627         op0 = convert (result_type, op0);
7628       if (TREE_TYPE (op1) != result_type)
7629         op1 = convert (result_type, op1);
7630
7631       /* This can happen if one operand has a vector type, and the other
7632          has a different type.  */
7633       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
7634         return error_mark_node;
7635     }
7636
7637   if (build_type == NULL_TREE)
7638     build_type = result_type;
7639
7640   {
7641     tree result = build2 (resultcode, build_type, op0, op1);
7642
7643     /* Treat expressions in initializers specially as they can't trap.  */
7644     result = require_constant_value ? fold_initializer (result)
7645                                     : fold (result);
7646
7647     if (final_type != 0)
7648       result = convert (final_type, result);
7649     return result;
7650   }
7651 }