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