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