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