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 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4116 static const char *constructor_asmspec;
4117
4118 /* Nonzero if this is an initializer for a top-level decl.  */
4119 static int constructor_top_level;
4120
4121 /* Nonzero if there were any member designators in this initializer.  */
4122 static int constructor_designated;
4123
4124 /* Nesting depth of designator list.  */
4125 static int designator_depth;
4126
4127 /* Nonzero if there were diagnosed errors in this designator list.  */
4128 static int designator_errorneous;
4129
4130 \f
4131 /* This stack has a level for each implicit or explicit level of
4132    structuring in the initializer, including the outermost one.  It
4133    saves the values of most of the variables above.  */
4134
4135 struct constructor_range_stack;
4136
4137 struct constructor_stack
4138 {
4139   struct constructor_stack *next;
4140   tree type;
4141   tree fields;
4142   tree index;
4143   tree max_index;
4144   tree unfilled_index;
4145   tree unfilled_fields;
4146   tree bit_index;
4147   tree elements;
4148   struct init_node *pending_elts;
4149   int offset;
4150   int depth;
4151   /* If nonzero, this value should replace the entire
4152      constructor at this level.  */
4153   tree replacement_value;
4154   struct constructor_range_stack *range_stack;
4155   char constant;
4156   char simple;
4157   char implicit;
4158   char erroneous;
4159   char outer;
4160   char incremental;
4161   char designated;
4162 };
4163
4164 struct constructor_stack *constructor_stack;
4165
4166 /* This stack represents designators from some range designator up to
4167    the last designator in the list.  */
4168
4169 struct constructor_range_stack
4170 {
4171   struct constructor_range_stack *next, *prev;
4172   struct constructor_stack *stack;
4173   tree range_start;
4174   tree index;
4175   tree range_end;
4176   tree fields;
4177 };
4178
4179 struct constructor_range_stack *constructor_range_stack;
4180
4181 /* This stack records separate initializers that are nested.
4182    Nested initializers can't happen in ANSI C, but GNU C allows them
4183    in cases like { ... (struct foo) { ... } ... }.  */
4184
4185 struct initializer_stack
4186 {
4187   struct initializer_stack *next;
4188   tree decl;
4189   const char *asmspec;
4190   struct constructor_stack *constructor_stack;
4191   struct constructor_range_stack *constructor_range_stack;
4192   tree elements;
4193   struct spelling *spelling;
4194   struct spelling *spelling_base;
4195   int spelling_size;
4196   char top_level;
4197   char require_constant_value;
4198   char require_constant_elements;
4199 };
4200
4201 struct initializer_stack *initializer_stack;
4202 \f
4203 /* Prepare to parse and output the initializer for variable DECL.  */
4204
4205 void
4206 start_init (tree decl, tree asmspec_tree, int top_level)
4207 {
4208   const char *locus;
4209   struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4210   const char *asmspec = 0;
4211
4212   if (asmspec_tree)
4213     asmspec = TREE_STRING_POINTER (asmspec_tree);
4214
4215   p->decl = constructor_decl;
4216   p->asmspec = constructor_asmspec;
4217   p->require_constant_value = require_constant_value;
4218   p->require_constant_elements = require_constant_elements;
4219   p->constructor_stack = constructor_stack;
4220   p->constructor_range_stack = constructor_range_stack;
4221   p->elements = constructor_elements;
4222   p->spelling = spelling;
4223   p->spelling_base = spelling_base;
4224   p->spelling_size = spelling_size;
4225   p->top_level = constructor_top_level;
4226   p->next = initializer_stack;
4227   initializer_stack = p;
4228
4229   constructor_decl = decl;
4230   constructor_asmspec = asmspec;
4231   constructor_designated = 0;
4232   constructor_top_level = top_level;
4233
4234   if (decl != 0)
4235     {
4236       require_constant_value = TREE_STATIC (decl);
4237       require_constant_elements
4238         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4239            /* For a scalar, you can always use any value to initialize,
4240               even within braces.  */
4241            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4242                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4243                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4244                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4245       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4246     }
4247   else
4248     {
4249       require_constant_value = 0;
4250       require_constant_elements = 0;
4251       locus = "(anonymous)";
4252     }
4253
4254   constructor_stack = 0;
4255   constructor_range_stack = 0;
4256
4257   missing_braces_mentioned = 0;
4258
4259   spelling_base = 0;
4260   spelling_size = 0;
4261   RESTORE_SPELLING_DEPTH (0);
4262
4263   if (locus)
4264     push_string (locus);
4265 }
4266
4267 void
4268 finish_init (void)
4269 {
4270   struct initializer_stack *p = initializer_stack;
4271
4272   /* Free the whole constructor stack of this initializer.  */
4273   while (constructor_stack)
4274     {
4275       struct constructor_stack *q = constructor_stack;
4276       constructor_stack = q->next;
4277       free (q);
4278     }
4279
4280   if (constructor_range_stack)
4281     abort ();
4282
4283   /* Pop back to the data of the outer initializer (if any).  */
4284   free (spelling_base);
4285
4286   constructor_decl = p->decl;
4287   constructor_asmspec = p->asmspec;
4288   require_constant_value = p->require_constant_value;
4289   require_constant_elements = p->require_constant_elements;
4290   constructor_stack = p->constructor_stack;
4291   constructor_range_stack = p->constructor_range_stack;
4292   constructor_elements = p->elements;
4293   spelling = p->spelling;
4294   spelling_base = p->spelling_base;
4295   spelling_size = p->spelling_size;
4296   constructor_top_level = p->top_level;
4297   initializer_stack = p->next;
4298   free (p);
4299 }
4300 \f
4301 /* Call here when we see the initializer is surrounded by braces.
4302    This is instead of a call to push_init_level;
4303    it is matched by a call to pop_init_level.
4304
4305    TYPE is the type to initialize, for a constructor expression.
4306    For an initializer for a decl, TYPE is zero.  */
4307
4308 void
4309 really_start_incremental_init (tree type)
4310 {
4311   struct constructor_stack *p = xmalloc (sizeof (struct constructor_stack));
4312
4313   if (type == 0)
4314     type = TREE_TYPE (constructor_decl);
4315
4316   if ((*targetm.vector_opaque_p) (type))
4317     error ("opaque vector types cannot be initialized");
4318
4319   p->type = constructor_type;
4320   p->fields = constructor_fields;
4321   p->index = constructor_index;
4322   p->max_index = constructor_max_index;
4323   p->unfilled_index = constructor_unfilled_index;
4324   p->unfilled_fields = constructor_unfilled_fields;
4325   p->bit_index = constructor_bit_index;
4326   p->elements = constructor_elements;
4327   p->constant = constructor_constant;
4328   p->simple = constructor_simple;
4329   p->erroneous = constructor_erroneous;
4330   p->pending_elts = constructor_pending_elts;
4331   p->depth = constructor_depth;
4332   p->replacement_value = 0;
4333   p->implicit = 0;
4334   p->range_stack = 0;
4335   p->outer = 0;
4336   p->incremental = constructor_incremental;
4337   p->designated = constructor_designated;
4338   p->next = 0;
4339   constructor_stack = p;
4340
4341   constructor_constant = 1;
4342   constructor_simple = 1;
4343   constructor_depth = SPELLING_DEPTH ();
4344   constructor_elements = 0;
4345   constructor_pending_elts = 0;
4346   constructor_type = type;
4347   constructor_incremental = 1;
4348   constructor_designated = 0;
4349   designator_depth = 0;
4350   designator_errorneous = 0;
4351
4352   if (TREE_CODE (constructor_type) == RECORD_TYPE
4353       || TREE_CODE (constructor_type) == UNION_TYPE)
4354     {
4355       constructor_fields = TYPE_FIELDS (constructor_type);
4356       /* Skip any nameless bit fields at the beginning.  */
4357       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4358              && DECL_NAME (constructor_fields) == 0)
4359         constructor_fields = TREE_CHAIN (constructor_fields);
4360
4361       constructor_unfilled_fields = constructor_fields;
4362       constructor_bit_index = bitsize_zero_node;
4363     }
4364   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4365     {
4366       if (TYPE_DOMAIN (constructor_type))
4367         {
4368           constructor_max_index
4369             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4370
4371           /* Detect non-empty initializations of zero-length arrays.  */
4372           if (constructor_max_index == NULL_TREE
4373               && TYPE_SIZE (constructor_type))
4374             constructor_max_index = build_int_2 (-1, -1);
4375
4376           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4377              to initialize VLAs will cause a proper error; avoid tree
4378              checking errors as well by setting a safe value.  */
4379           if (constructor_max_index
4380               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4381             constructor_max_index = build_int_2 (-1, -1);
4382
4383           constructor_index
4384             = convert (bitsizetype,
4385                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4386         }
4387       else
4388         constructor_index = bitsize_zero_node;
4389
4390       constructor_unfilled_index = constructor_index;
4391     }
4392   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4393     {
4394       /* Vectors are like simple fixed-size arrays.  */
4395       constructor_max_index =
4396         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4397       constructor_index = convert (bitsizetype, bitsize_zero_node);
4398       constructor_unfilled_index = constructor_index;
4399     }
4400   else
4401     {
4402       /* Handle the case of int x = {5}; */
4403       constructor_fields = constructor_type;
4404       constructor_unfilled_fields = constructor_type;
4405     }
4406 }
4407 \f
4408 /* Push down into a subobject, for initialization.
4409    If this is for an explicit set of braces, IMPLICIT is 0.
4410    If it is because the next element belongs at a lower level,
4411    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4412
4413 void
4414 push_init_level (int implicit)
4415 {
4416   struct constructor_stack *p;
4417   tree value = NULL_TREE;
4418
4419   /* If we've exhausted any levels that didn't have braces,
4420      pop them now.  */
4421   while (constructor_stack->implicit)
4422     {
4423       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4424            || TREE_CODE (constructor_type) == UNION_TYPE)
4425           && constructor_fields == 0)
4426         process_init_element (pop_init_level (1));
4427       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4428                && constructor_max_index
4429                && tree_int_cst_lt (constructor_max_index, constructor_index))
4430         process_init_element (pop_init_level (1));
4431       else
4432         break;
4433     }
4434
4435   /* Unless this is an explicit brace, we need to preserve previous
4436      content if any.  */
4437   if (implicit)
4438     {
4439       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4440            || TREE_CODE (constructor_type) == UNION_TYPE)
4441           && constructor_fields)
4442         value = find_init_member (constructor_fields);
4443       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4444         value = find_init_member (constructor_index);
4445     }
4446
4447   p = xmalloc (sizeof (struct constructor_stack));
4448   p->type = constructor_type;
4449   p->fields = constructor_fields;
4450   p->index = constructor_index;
4451   p->max_index = constructor_max_index;
4452   p->unfilled_index = constructor_unfilled_index;
4453   p->unfilled_fields = constructor_unfilled_fields;
4454   p->bit_index = constructor_bit_index;
4455   p->elements = constructor_elements;
4456   p->constant = constructor_constant;
4457   p->simple = constructor_simple;
4458   p->erroneous = constructor_erroneous;
4459   p->pending_elts = constructor_pending_elts;
4460   p->depth = constructor_depth;
4461   p->replacement_value = 0;
4462   p->implicit = implicit;
4463   p->outer = 0;
4464   p->incremental = constructor_incremental;
4465   p->designated = constructor_designated;
4466   p->next = constructor_stack;
4467   p->range_stack = 0;
4468   constructor_stack = p;
4469
4470   constructor_constant = 1;
4471   constructor_simple = 1;
4472   constructor_depth = SPELLING_DEPTH ();
4473   constructor_elements = 0;
4474   constructor_incremental = 1;
4475   constructor_designated = 0;
4476   constructor_pending_elts = 0;
4477   if (!implicit)
4478     {
4479       p->range_stack = constructor_range_stack;
4480       constructor_range_stack = 0;
4481       designator_depth = 0;
4482       designator_errorneous = 0;
4483     }
4484
4485   /* Don't die if an entire brace-pair level is superfluous
4486      in the containing level.  */
4487   if (constructor_type == 0)
4488     ;
4489   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4490            || TREE_CODE (constructor_type) == UNION_TYPE)
4491     {
4492       /* Don't die if there are extra init elts at the end.  */
4493       if (constructor_fields == 0)
4494         constructor_type = 0;
4495       else
4496         {
4497           constructor_type = TREE_TYPE (constructor_fields);
4498           push_member_name (constructor_fields);
4499           constructor_depth++;
4500         }
4501     }
4502   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4503     {
4504       constructor_type = TREE_TYPE (constructor_type);
4505       push_array_bounds (tree_low_cst (constructor_index, 0));
4506       constructor_depth++;
4507     }
4508
4509   if (constructor_type == 0)
4510     {
4511       error_init ("extra brace group at end of initializer");
4512       constructor_fields = 0;
4513       constructor_unfilled_fields = 0;
4514       return;
4515     }
4516
4517   if (value && TREE_CODE (value) == CONSTRUCTOR)
4518     {
4519       constructor_constant = TREE_CONSTANT (value);
4520       constructor_simple = TREE_STATIC (value);
4521       constructor_elements = CONSTRUCTOR_ELTS (value);
4522       if (constructor_elements
4523           && (TREE_CODE (constructor_type) == RECORD_TYPE
4524               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4525         set_nonincremental_init ();
4526     }
4527
4528   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4529     {
4530       missing_braces_mentioned = 1;
4531       warning_init ("missing braces around initializer");
4532     }
4533
4534   if (TREE_CODE (constructor_type) == RECORD_TYPE
4535            || TREE_CODE (constructor_type) == UNION_TYPE)
4536     {
4537       constructor_fields = TYPE_FIELDS (constructor_type);
4538       /* Skip any nameless bit fields at the beginning.  */
4539       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4540              && DECL_NAME (constructor_fields) == 0)
4541         constructor_fields = TREE_CHAIN (constructor_fields);
4542
4543       constructor_unfilled_fields = constructor_fields;
4544       constructor_bit_index = bitsize_zero_node;
4545     }
4546   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4547     {
4548       /* Vectors are like simple fixed-size arrays.  */
4549       constructor_max_index =
4550         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4551       constructor_index = convert (bitsizetype, integer_zero_node);
4552       constructor_unfilled_index = constructor_index;
4553     }
4554   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4555     {
4556       if (TYPE_DOMAIN (constructor_type))
4557         {
4558           constructor_max_index
4559             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4560
4561           /* Detect non-empty initializations of zero-length arrays.  */
4562           if (constructor_max_index == NULL_TREE
4563               && TYPE_SIZE (constructor_type))
4564             constructor_max_index = build_int_2 (-1, -1);
4565
4566           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4567              to initialize VLAs will cause a proper error; avoid tree
4568              checking errors as well by setting a safe value.  */
4569           if (constructor_max_index
4570               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4571             constructor_max_index = build_int_2 (-1, -1);
4572
4573           constructor_index
4574             = convert (bitsizetype,
4575                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4576         }
4577       else
4578         constructor_index = bitsize_zero_node;
4579
4580       constructor_unfilled_index = constructor_index;
4581       if (value && TREE_CODE (value) == STRING_CST)
4582         {
4583           /* We need to split the char/wchar array into individual
4584              characters, so that we don't have to special case it
4585              everywhere.  */
4586           set_nonincremental_init_from_string (value);
4587         }
4588     }
4589   else
4590     {
4591       warning_init ("braces around scalar initializer");
4592       constructor_fields = constructor_type;
4593       constructor_unfilled_fields = constructor_type;
4594     }
4595 }
4596
4597 /* At the end of an implicit or explicit brace level,
4598    finish up that level of constructor.
4599    If we were outputting the elements as they are read, return 0
4600    from inner levels (process_init_element ignores that),
4601    but return error_mark_node from the outermost level
4602    (that's what we want to put in DECL_INITIAL).
4603    Otherwise, return a CONSTRUCTOR expression.  */
4604
4605 tree
4606 pop_init_level (int implicit)
4607 {
4608   struct constructor_stack *p;
4609   tree constructor = 0;
4610
4611   if (implicit == 0)
4612     {
4613       /* When we come to an explicit close brace,
4614          pop any inner levels that didn't have explicit braces.  */
4615       while (constructor_stack->implicit)
4616         process_init_element (pop_init_level (1));
4617
4618       if (constructor_range_stack)
4619         abort ();
4620     }
4621
4622   p = constructor_stack;
4623
4624   /* Error for initializing a flexible array member, or a zero-length
4625      array member in an inappropriate context.  */
4626   if (constructor_type && constructor_fields
4627       && TREE_CODE (constructor_type) == ARRAY_TYPE
4628       && TYPE_DOMAIN (constructor_type)
4629       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4630     {
4631       /* Silently discard empty initializations.  The parser will
4632          already have pedwarned for empty brackets.  */
4633       if (integer_zerop (constructor_unfilled_index))
4634         constructor_type = NULL_TREE;
4635       else if (! TYPE_SIZE (constructor_type))
4636         {
4637           if (constructor_depth > 2)
4638             error_init ("initialization of flexible array member in a nested context");
4639           else if (pedantic)
4640             pedwarn_init ("initialization of a flexible array member");
4641
4642           /* We have already issued an error message for the existence
4643              of a flexible array member not at the end of the structure.
4644              Discard the initializer so that we do not abort later.  */
4645           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4646             constructor_type = NULL_TREE;
4647         }
4648       else
4649         /* Zero-length arrays are no longer special, so we should no longer
4650            get here.  */
4651         abort ();
4652     }
4653
4654   /* Warn when some struct elements are implicitly initialized to zero.  */
4655   if (extra_warnings
4656       && constructor_type
4657       && TREE_CODE (constructor_type) == RECORD_TYPE
4658       && constructor_unfilled_fields)
4659     {
4660         /* Do not warn for flexible array members or zero-length arrays.  */
4661         while (constructor_unfilled_fields
4662                && (! DECL_SIZE (constructor_unfilled_fields)
4663                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4664           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4665
4666         /* Do not warn if this level of the initializer uses member
4667            designators; it is likely to be deliberate.  */
4668         if (constructor_unfilled_fields && !constructor_designated)
4669           {
4670             push_member_name (constructor_unfilled_fields);
4671             warning_init ("missing initializer");
4672             RESTORE_SPELLING_DEPTH (constructor_depth);
4673           }
4674     }
4675
4676   /* Now output all pending elements.  */
4677   constructor_incremental = 1;
4678   output_pending_init_elements (1);
4679
4680   /* Pad out the end of the structure.  */
4681   if (p->replacement_value)
4682     /* If this closes a superfluous brace pair,
4683        just pass out the element between them.  */
4684     constructor = p->replacement_value;
4685   else if (constructor_type == 0)
4686     ;
4687   else if (TREE_CODE (constructor_type) != RECORD_TYPE
4688            && TREE_CODE (constructor_type) != UNION_TYPE
4689            && TREE_CODE (constructor_type) != ARRAY_TYPE
4690            && TREE_CODE (constructor_type) != VECTOR_TYPE)
4691     {
4692       /* A nonincremental scalar initializer--just return
4693          the element, after verifying there is just one.  */
4694       if (constructor_elements == 0)
4695         {
4696           if (!constructor_erroneous)
4697             error_init ("empty scalar initializer");
4698           constructor = error_mark_node;
4699         }
4700       else if (TREE_CHAIN (constructor_elements) != 0)
4701         {
4702           error_init ("extra elements in scalar initializer");
4703           constructor = TREE_VALUE (constructor_elements);
4704         }
4705       else
4706         constructor = TREE_VALUE (constructor_elements);
4707     }
4708   else
4709     {
4710       if (constructor_erroneous)
4711         constructor = error_mark_node;
4712       else
4713         {
4714           constructor = build_constructor (constructor_type,
4715                                            nreverse (constructor_elements));
4716           if (constructor_constant)
4717             TREE_CONSTANT (constructor) = 1;
4718           if (constructor_constant && constructor_simple)
4719             TREE_STATIC (constructor) = 1;
4720         }
4721     }
4722
4723   constructor_type = p->type;
4724   constructor_fields = p->fields;
4725   constructor_index = p->index;
4726   constructor_max_index = p->max_index;
4727   constructor_unfilled_index = p->unfilled_index;
4728   constructor_unfilled_fields = p->unfilled_fields;
4729   constructor_bit_index = p->bit_index;
4730   constructor_elements = p->elements;
4731   constructor_constant = p->constant;
4732   constructor_simple = p->simple;
4733   constructor_erroneous = p->erroneous;
4734   constructor_incremental = p->incremental;
4735   constructor_designated = p->designated;
4736   constructor_pending_elts = p->pending_elts;
4737   constructor_depth = p->depth;
4738   if (!p->implicit)
4739     constructor_range_stack = p->range_stack;
4740   RESTORE_SPELLING_DEPTH (constructor_depth);
4741
4742   constructor_stack = p->next;
4743   free (p);
4744
4745   if (constructor == 0)
4746     {
4747       if (constructor_stack == 0)
4748         return error_mark_node;
4749       return NULL_TREE;
4750     }
4751   return constructor;
4752 }
4753
4754 /* Common handling for both array range and field name designators.
4755    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
4756
4757 static int
4758 set_designator (int array)
4759 {
4760   tree subtype;
4761   enum tree_code subcode;
4762
4763   /* Don't die if an entire brace-pair level is superfluous
4764      in the containing level.  */
4765   if (constructor_type == 0)
4766     return 1;
4767
4768   /* If there were errors in this designator list already, bail out silently.  */
4769   if (designator_errorneous)
4770     return 1;
4771
4772   if (!designator_depth)
4773     {
4774       if (constructor_range_stack)
4775         abort ();
4776
4777       /* Designator list starts at the level of closest explicit
4778          braces.  */
4779       while (constructor_stack->implicit)
4780         process_init_element (pop_init_level (1));
4781       constructor_designated = 1;
4782       return 0;
4783     }
4784
4785   if (constructor_no_implicit)
4786     {
4787       error_init ("initialization designators may not nest");
4788       return 1;
4789     }
4790
4791   if (TREE_CODE (constructor_type) == RECORD_TYPE
4792       || TREE_CODE (constructor_type) == UNION_TYPE)
4793     {
4794       subtype = TREE_TYPE (constructor_fields);
4795       if (subtype != error_mark_node)
4796         subtype = TYPE_MAIN_VARIANT (subtype);
4797     }
4798   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4799     {
4800       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
4801     }
4802   else
4803     abort ();
4804
4805   subcode = TREE_CODE (subtype);
4806   if (array && subcode != ARRAY_TYPE)
4807     {
4808       error_init ("array index in non-array initializer");
4809       return 1;
4810     }
4811   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
4812     {
4813       error_init ("field name not in record or union initializer");
4814       return 1;
4815     }
4816
4817   constructor_designated = 1;
4818   push_init_level (2);
4819   return 0;
4820 }
4821
4822 /* If there are range designators in designator list, push a new designator
4823    to constructor_range_stack.  RANGE_END is end of such stack range or
4824    NULL_TREE if there is no range designator at this level.  */
4825
4826 static void
4827 push_range_stack (tree range_end)
4828 {
4829   struct constructor_range_stack *p;
4830
4831   p = ggc_alloc (sizeof (struct constructor_range_stack));
4832   p->prev = constructor_range_stack;
4833   p->next = 0;
4834   p->fields = constructor_fields;
4835   p->range_start = constructor_index;
4836   p->index = constructor_index;
4837   p->stack = constructor_stack;
4838   p->range_end = range_end;
4839   if (constructor_range_stack)
4840     constructor_range_stack->next = p;
4841   constructor_range_stack = p;
4842 }
4843
4844 /* Within an array initializer, specify the next index to be initialized.
4845    FIRST is that index.  If LAST is nonzero, then initialize a range
4846    of indices, running from FIRST through LAST.  */
4847
4848 void
4849 set_init_index (tree first, tree last)
4850 {
4851   if (set_designator (1))
4852     return;
4853
4854   designator_errorneous = 1;
4855
4856   while ((TREE_CODE (first) == NOP_EXPR
4857           || TREE_CODE (first) == CONVERT_EXPR
4858           || TREE_CODE (first) == NON_LVALUE_EXPR)
4859          && (TYPE_MODE (TREE_TYPE (first))
4860              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
4861     first = TREE_OPERAND (first, 0);
4862
4863   if (last)
4864     while ((TREE_CODE (last) == NOP_EXPR
4865             || TREE_CODE (last) == CONVERT_EXPR
4866             || TREE_CODE (last) == NON_LVALUE_EXPR)
4867            && (TYPE_MODE (TREE_TYPE (last))
4868                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
4869       last = TREE_OPERAND (last, 0);
4870
4871   if (TREE_CODE (first) != INTEGER_CST)
4872     error_init ("nonconstant array index in initializer");
4873   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
4874     error_init ("nonconstant array index in initializer");
4875   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
4876     error_init ("array index in non-array initializer");
4877   else if (tree_int_cst_sgn (first) == -1)
4878     error_init ("array index in initializer exceeds array bounds");
4879   else if (constructor_max_index
4880            && tree_int_cst_lt (constructor_max_index, first))
4881     error_init ("array index in initializer exceeds array bounds");
4882   else
4883     {
4884       constructor_index = convert (bitsizetype, first);
4885
4886       if (last)
4887         {
4888           if (tree_int_cst_equal (first, last))
4889             last = 0;
4890           else if (tree_int_cst_lt (last, first))
4891             {
4892               error_init ("empty index range in initializer");
4893               last = 0;
4894             }
4895           else
4896             {
4897               last = convert (bitsizetype, last);
4898               if (constructor_max_index != 0
4899                   && tree_int_cst_lt (constructor_max_index, last))
4900                 {
4901                   error_init ("array index range in initializer exceeds array bounds");
4902                   last = 0;
4903                 }
4904             }
4905         }
4906
4907       designator_depth++;
4908       designator_errorneous = 0;
4909       if (constructor_range_stack || last)
4910         push_range_stack (last);
4911     }
4912 }
4913
4914 /* Within a struct initializer, specify the next field to be initialized.  */
4915
4916 void
4917 set_init_label (tree fieldname)
4918 {
4919   tree tail;
4920
4921   if (set_designator (0))
4922     return;
4923
4924   designator_errorneous = 1;
4925
4926   if (TREE_CODE (constructor_type) != RECORD_TYPE
4927       && TREE_CODE (constructor_type) != UNION_TYPE)
4928     {
4929       error_init ("field name not in record or union initializer");
4930       return;
4931     }
4932
4933   for (tail = TYPE_FIELDS (constructor_type); tail;
4934        tail = TREE_CHAIN (tail))
4935     {
4936       if (DECL_NAME (tail) == fieldname)
4937         break;
4938     }
4939
4940   if (tail == 0)
4941     error ("unknown field `%s' specified in initializer",
4942            IDENTIFIER_POINTER (fieldname));
4943   else
4944     {
4945       constructor_fields = tail;
4946       designator_depth++;
4947       designator_errorneous = 0;
4948       if (constructor_range_stack)
4949         push_range_stack (NULL_TREE);
4950     }
4951 }
4952 \f
4953 /* Add a new initializer to the tree of pending initializers.  PURPOSE
4954    identifies the initializer, either array index or field in a structure.
4955    VALUE is the value of that index or field.  */
4956
4957 static void
4958 add_pending_init (tree purpose, tree value)
4959 {
4960   struct init_node *p, **q, *r;
4961
4962   q = &constructor_pending_elts;
4963   p = 0;
4964
4965   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4966     {
4967       while (*q != 0)
4968         {
4969           p = *q;
4970           if (tree_int_cst_lt (purpose, p->purpose))
4971             q = &p->left;
4972           else if (tree_int_cst_lt (p->purpose, purpose))
4973             q = &p->right;
4974           else
4975             {
4976               if (TREE_SIDE_EFFECTS (p->value))
4977                 warning_init ("initialized field with side-effects overwritten");
4978               p->value = value;
4979               return;
4980             }
4981         }
4982     }
4983   else
4984     {
4985       tree bitpos;
4986
4987       bitpos = bit_position (purpose);
4988       while (*q != NULL)
4989         {
4990           p = *q;
4991           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
4992             q = &p->left;
4993           else if (p->purpose != purpose)
4994             q = &p->right;
4995           else
4996             {
4997               if (TREE_SIDE_EFFECTS (p->value))
4998                 warning_init ("initialized field with side-effects overwritten");
4999               p->value = value;
5000               return;
5001             }
5002         }
5003     }
5004
5005   r = ggc_alloc (sizeof (struct init_node));
5006   r->purpose = purpose;
5007   r->value = value;
5008
5009   *q = r;
5010   r->parent = p;
5011   r->left = 0;
5012   r->right = 0;
5013   r->balance = 0;
5014
5015   while (p)
5016     {
5017       struct init_node *s;
5018
5019       if (r == p->left)
5020         {
5021           if (p->balance == 0)
5022             p->balance = -1;
5023           else if (p->balance < 0)
5024             {
5025               if (r->balance < 0)
5026                 {
5027                   /* L rotation.  */
5028                   p->left = r->right;
5029                   if (p->left)
5030                     p->left->parent = p;
5031                   r->right = p;
5032
5033                   p->balance = 0;
5034                   r->balance = 0;
5035
5036                   s = p->parent;
5037                   p->parent = r;
5038                   r->parent = s;
5039                   if (s)
5040                     {
5041                       if (s->left == p)
5042                         s->left = r;
5043                       else
5044                         s->right = r;
5045                     }
5046                   else
5047                     constructor_pending_elts = r;
5048                 }
5049               else
5050                 {
5051                   /* LR rotation.  */
5052                   struct init_node *t = r->right;
5053
5054                   r->right = t->left;
5055                   if (r->right)
5056                     r->right->parent = r;
5057                   t->left = r;
5058
5059                   p->left = t->right;
5060                   if (p->left)
5061                     p->left->parent = p;
5062                   t->right = p;
5063
5064                   p->balance = t->balance < 0;
5065                   r->balance = -(t->balance > 0);
5066                   t->balance = 0;
5067
5068                   s = p->parent;
5069                   p->parent = t;
5070                   r->parent = t;
5071                   t->parent = s;
5072                   if (s)
5073                     {
5074                       if (s->left == p)
5075                         s->left = t;
5076                       else
5077                         s->right = t;
5078                     }
5079                   else
5080                     constructor_pending_elts = t;
5081                 }
5082               break;
5083             }
5084           else
5085             {
5086               /* p->balance == +1; growth of left side balances the node.  */
5087               p->balance = 0;
5088               break;
5089             }
5090         }
5091       else /* r == p->right */
5092         {
5093           if (p->balance == 0)
5094             /* Growth propagation from right side.  */
5095             p->balance++;
5096           else if (p->balance > 0)
5097             {
5098               if (r->balance > 0)
5099                 {
5100                   /* R rotation.  */
5101                   p->right = r->left;
5102                   if (p->right)
5103                     p->right->parent = p;
5104                   r->left = p;
5105
5106                   p->balance = 0;
5107                   r->balance = 0;
5108
5109                   s = p->parent;
5110                   p->parent = r;
5111                   r->parent = s;
5112                   if (s)
5113                     {
5114                       if (s->left == p)
5115                         s->left = r;
5116                       else
5117                         s->right = r;
5118                     }
5119                   else
5120                     constructor_pending_elts = r;
5121                 }
5122               else /* r->balance == -1 */
5123                 {
5124                   /* RL rotation */
5125                   struct init_node *t = r->left;
5126
5127                   r->left = t->right;
5128                   if (r->left)
5129                     r->left->parent = r;
5130                   t->right = r;
5131
5132                   p->right = t->left;
5133                   if (p->right)
5134                     p->right->parent = p;
5135                   t->left = p;
5136
5137                   r->balance = (t->balance < 0);
5138                   p->balance = -(t->balance > 0);
5139                   t->balance = 0;
5140
5141                   s = p->parent;
5142                   p->parent = t;
5143                   r->parent = t;
5144                   t->parent = s;
5145                   if (s)
5146                     {
5147                       if (s->left == p)
5148                         s->left = t;
5149                       else
5150                         s->right = t;
5151                     }
5152                   else
5153                     constructor_pending_elts = t;
5154                 }
5155               break;
5156             }
5157           else
5158             {
5159               /* p->balance == -1; growth of right side balances the node.  */
5160               p->balance = 0;
5161               break;
5162             }
5163         }
5164
5165       r = p;
5166       p = p->parent;
5167     }
5168 }
5169
5170 /* Build AVL tree from a sorted chain.  */
5171
5172 static void
5173 set_nonincremental_init (void)
5174 {
5175   tree chain;
5176
5177   if (TREE_CODE (constructor_type) != RECORD_TYPE
5178       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5179     return;
5180
5181   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5182     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5183   constructor_elements = 0;
5184   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5185     {
5186       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5187       /* Skip any nameless bit fields at the beginning.  */
5188       while (constructor_unfilled_fields != 0
5189              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5190              && DECL_NAME (constructor_unfilled_fields) == 0)
5191         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5192
5193     }
5194   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5195     {
5196       if (TYPE_DOMAIN (constructor_type))
5197         constructor_unfilled_index
5198             = convert (bitsizetype,
5199                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5200       else
5201         constructor_unfilled_index = bitsize_zero_node;
5202     }
5203   constructor_incremental = 0;
5204 }
5205
5206 /* Build AVL tree from a string constant.  */
5207
5208 static void
5209 set_nonincremental_init_from_string (tree str)
5210 {
5211   tree value, purpose, type;
5212   HOST_WIDE_INT val[2];
5213   const char *p, *end;
5214   int byte, wchar_bytes, charwidth, bitpos;
5215
5216   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5217     abort ();
5218
5219   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5220       == TYPE_PRECISION (char_type_node))
5221     wchar_bytes = 1;
5222   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5223            == TYPE_PRECISION (wchar_type_node))
5224     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5225   else
5226     abort ();
5227
5228   charwidth = TYPE_PRECISION (char_type_node);
5229   type = TREE_TYPE (constructor_type);
5230   p = TREE_STRING_POINTER (str);
5231   end = p + TREE_STRING_LENGTH (str);
5232
5233   for (purpose = bitsize_zero_node;
5234        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5235        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5236     {
5237       if (wchar_bytes == 1)
5238         {
5239           val[1] = (unsigned char) *p++;
5240           val[0] = 0;
5241         }
5242       else
5243         {
5244           val[0] = 0;
5245           val[1] = 0;
5246           for (byte = 0; byte < wchar_bytes; byte++)
5247             {
5248               if (BYTES_BIG_ENDIAN)
5249                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5250               else
5251                 bitpos = byte * charwidth;
5252               val[bitpos < HOST_BITS_PER_WIDE_INT]
5253                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5254                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5255             }
5256         }
5257
5258       if (!TREE_UNSIGNED (type))
5259         {
5260           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5261           if (bitpos < HOST_BITS_PER_WIDE_INT)
5262             {
5263               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5264                 {
5265                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5266                   val[0] = -1;
5267                 }
5268             }
5269           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5270             {
5271               if (val[1] < 0)
5272                 val[0] = -1;
5273             }
5274           else if (val[0] & (((HOST_WIDE_INT) 1)
5275                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5276             val[0] |= ((HOST_WIDE_INT) -1)
5277                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5278         }
5279
5280       value = build_int_2 (val[1], val[0]);
5281       TREE_TYPE (value) = type;
5282       add_pending_init (purpose, value);
5283     }
5284
5285   constructor_incremental = 0;
5286 }
5287
5288 /* Return value of FIELD in pending initializer or zero if the field was
5289    not initialized yet.  */
5290
5291 static tree
5292 find_init_member (tree field)
5293 {
5294   struct init_node *p;
5295
5296   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5297     {
5298       if (constructor_incremental
5299           && tree_int_cst_lt (field, constructor_unfilled_index))
5300         set_nonincremental_init ();
5301
5302       p = constructor_pending_elts;
5303       while (p)
5304         {
5305           if (tree_int_cst_lt (field, p->purpose))
5306             p = p->left;
5307           else if (tree_int_cst_lt (p->purpose, field))
5308             p = p->right;
5309           else
5310             return p->value;
5311         }
5312     }
5313   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5314     {
5315       tree bitpos = bit_position (field);
5316
5317       if (constructor_incremental
5318           && (!constructor_unfilled_fields
5319               || tree_int_cst_lt (bitpos,
5320                                   bit_position (constructor_unfilled_fields))))
5321         set_nonincremental_init ();
5322
5323       p = constructor_pending_elts;
5324       while (p)
5325         {
5326           if (field == p->purpose)
5327             return p->value;
5328           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5329             p = p->left;
5330           else
5331             p = p->right;
5332         }
5333     }
5334   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5335     {
5336       if (constructor_elements
5337           && TREE_PURPOSE (constructor_elements) == field)
5338         return TREE_VALUE (constructor_elements);
5339     }
5340   return 0;
5341 }
5342
5343 /* "Output" the next constructor element.
5344    At top level, really output it to assembler code now.
5345    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5346    TYPE is the data type that the containing data type wants here.
5347    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5348
5349    PENDING if non-nil means output pending elements that belong
5350    right after this element.  (PENDING is normally 1;
5351    it is 0 while outputting pending elements, to avoid recursion.)  */
5352
5353 static void
5354 output_init_element (tree value, tree type, tree field, int pending)
5355 {
5356   if (type == error_mark_node)
5357     {
5358       constructor_erroneous = 1;
5359       return;
5360     }
5361   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5362       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5363           && !(TREE_CODE (value) == STRING_CST
5364                && TREE_CODE (type) == ARRAY_TYPE
5365                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5366           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5367                          TYPE_MAIN_VARIANT (type), COMPARE_STRICT)))
5368     value = default_conversion (value);
5369
5370   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5371       && require_constant_value && !flag_isoc99 && pending)
5372     {
5373       /* As an extension, allow initializing objects with static storage
5374          duration with compound literals (which are then treated just as
5375          the brace enclosed list they contain).  */
5376       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5377       value = DECL_INITIAL (decl);
5378     }
5379
5380   if (value == error_mark_node)
5381     constructor_erroneous = 1;
5382   else if (!TREE_CONSTANT (value))
5383     constructor_constant = 0;
5384   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5385            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5386                 || TREE_CODE (constructor_type) == UNION_TYPE)
5387                && DECL_C_BIT_FIELD (field)
5388                && TREE_CODE (value) != INTEGER_CST))
5389     constructor_simple = 0;
5390
5391   if (require_constant_value && ! TREE_CONSTANT (value))
5392     {
5393       error_init ("initializer element is not constant");
5394       value = error_mark_node;
5395     }
5396   else if (require_constant_elements
5397            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5398     pedwarn ("initializer element is not computable at load time");
5399
5400   /* If this field is empty (and not at the end of structure),
5401      don't do anything other than checking the initializer.  */
5402   if (field
5403       && (TREE_TYPE (field) == error_mark_node
5404           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5405               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5406               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5407                   || TREE_CHAIN (field)))))
5408     return;
5409
5410   value = digest_init (type, value, require_constant_value);
5411   if (value == error_mark_node)
5412     {
5413       constructor_erroneous = 1;
5414       return;
5415     }
5416
5417   /* If this element doesn't come next in sequence,
5418      put it on constructor_pending_elts.  */
5419   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5420       && (!constructor_incremental
5421           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5422     {
5423       if (constructor_incremental
5424           && tree_int_cst_lt (field, constructor_unfilled_index))
5425         set_nonincremental_init ();
5426
5427       add_pending_init (field, value);
5428       return;
5429     }
5430   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5431            && (!constructor_incremental
5432                || field != constructor_unfilled_fields))
5433     {
5434       /* We do this for records but not for unions.  In a union,
5435          no matter which field is specified, it can be initialized
5436          right away since it starts at the beginning of the union.  */
5437       if (constructor_incremental)
5438         {
5439           if (!constructor_unfilled_fields)
5440             set_nonincremental_init ();
5441           else
5442             {
5443               tree bitpos, unfillpos;
5444
5445               bitpos = bit_position (field);
5446               unfillpos = bit_position (constructor_unfilled_fields);
5447
5448               if (tree_int_cst_lt (bitpos, unfillpos))
5449                 set_nonincremental_init ();
5450             }
5451         }
5452
5453       add_pending_init (field, value);
5454       return;
5455     }
5456   else if (TREE_CODE (constructor_type) == UNION_TYPE
5457            && constructor_elements)
5458     {
5459       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5460         warning_init ("initialized field with side-effects overwritten");
5461
5462       /* We can have just one union field set.  */
5463       constructor_elements = 0;
5464     }
5465
5466   /* Otherwise, output this element either to
5467      constructor_elements or to the assembler file.  */
5468
5469   if (field && TREE_CODE (field) == INTEGER_CST)
5470     field = copy_node (field);
5471   constructor_elements
5472     = tree_cons (field, value, constructor_elements);
5473
5474   /* Advance the variable that indicates sequential elements output.  */
5475   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5476     constructor_unfilled_index
5477       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5478                     bitsize_one_node);
5479   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5480     {
5481       constructor_unfilled_fields
5482         = TREE_CHAIN (constructor_unfilled_fields);
5483
5484       /* Skip any nameless bit fields.  */
5485       while (constructor_unfilled_fields != 0
5486              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5487              && DECL_NAME (constructor_unfilled_fields) == 0)
5488         constructor_unfilled_fields =
5489           TREE_CHAIN (constructor_unfilled_fields);
5490     }
5491   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5492     constructor_unfilled_fields = 0;
5493
5494   /* Now output any pending elements which have become next.  */
5495   if (pending)
5496     output_pending_init_elements (0);
5497 }
5498
5499 /* Output any pending elements which have become next.
5500    As we output elements, constructor_unfilled_{fields,index}
5501    advances, which may cause other elements to become next;
5502    if so, they too are output.
5503
5504    If ALL is 0, we return when there are
5505    no more pending elements to output now.
5506
5507    If ALL is 1, we output space as necessary so that
5508    we can output all the pending elements.  */
5509
5510 static void
5511 output_pending_init_elements (int all)
5512 {
5513   struct init_node *elt = constructor_pending_elts;
5514   tree next;
5515
5516  retry:
5517
5518   /* Look through the whole pending tree.
5519      If we find an element that should be output now,
5520      output it.  Otherwise, set NEXT to the element
5521      that comes first among those still pending.  */
5522
5523   next = 0;
5524   while (elt)
5525     {
5526       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5527         {
5528           if (tree_int_cst_equal (elt->purpose,
5529                                   constructor_unfilled_index))
5530             output_init_element (elt->value,
5531                                  TREE_TYPE (constructor_type),
5532                                  constructor_unfilled_index, 0);
5533           else if (tree_int_cst_lt (constructor_unfilled_index,
5534                                     elt->purpose))
5535             {
5536               /* Advance to the next smaller node.  */
5537               if (elt->left)
5538                 elt = elt->left;
5539               else
5540                 {
5541                   /* We have reached the smallest node bigger than the
5542                      current unfilled index.  Fill the space first.  */
5543                   next = elt->purpose;
5544                   break;
5545                 }
5546             }
5547           else
5548             {
5549               /* Advance to the next bigger node.  */
5550               if (elt->right)
5551                 elt = elt->right;
5552               else
5553                 {
5554                   /* We have reached the biggest node in a subtree.  Find
5555                      the parent of it, which is the next bigger node.  */
5556                   while (elt->parent && elt->parent->right == elt)
5557                     elt = elt->parent;
5558                   elt = elt->parent;
5559                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5560                                               elt->purpose))
5561                     {
5562                       next = elt->purpose;
5563                       break;
5564                     }
5565                 }
5566             }
5567         }
5568       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5569                || TREE_CODE (constructor_type) == UNION_TYPE)
5570         {
5571           tree ctor_unfilled_bitpos, elt_bitpos;
5572
5573           /* If the current record is complete we are done.  */
5574           if (constructor_unfilled_fields == 0)
5575             break;
5576
5577           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5578           elt_bitpos = bit_position (elt->purpose);
5579           /* We can't compare fields here because there might be empty
5580              fields in between.  */
5581           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5582             {
5583               constructor_unfilled_fields = elt->purpose;
5584               output_init_element (elt->value, TREE_TYPE (elt->purpose),
5585                                    elt->purpose, 0);
5586             }
5587           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5588             {
5589               /* Advance to the next smaller node.  */
5590               if (elt->left)
5591                 elt = elt->left;
5592               else
5593                 {
5594                   /* We have reached the smallest node bigger than the
5595                      current unfilled field.  Fill the space first.  */
5596                   next = elt->purpose;
5597                   break;
5598                 }
5599             }
5600           else
5601             {
5602               /* Advance to the next bigger node.  */
5603               if (elt->right)
5604                 elt = elt->right;
5605               else
5606                 {
5607                   /* We have reached the biggest node in a subtree.  Find
5608                      the parent of it, which is the next bigger node.  */
5609                   while (elt->parent && elt->parent->right == elt)
5610                     elt = elt->parent;
5611                   elt = elt->parent;
5612                   if (elt
5613                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
5614                                            bit_position (elt->purpose))))
5615                     {
5616                       next = elt->purpose;
5617                       break;
5618                     }
5619                 }
5620             }
5621         }
5622     }
5623
5624   /* Ordinarily return, but not if we want to output all
5625      and there are elements left.  */
5626   if (! (all && next != 0))
5627     return;
5628
5629   /* If it's not incremental, just skip over the gap, so that after
5630      jumping to retry we will output the next successive element.  */
5631   if (TREE_CODE (constructor_type) == RECORD_TYPE
5632       || TREE_CODE (constructor_type) == UNION_TYPE)
5633     constructor_unfilled_fields = next;
5634   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5635     constructor_unfilled_index = next;
5636
5637   /* ELT now points to the node in the pending tree with the next
5638      initializer to output.  */
5639   goto retry;
5640 }
5641 \f
5642 /* Add one non-braced element to the current constructor level.
5643    This adjusts the current position within the constructor's type.
5644    This may also start or terminate implicit levels
5645    to handle a partly-braced initializer.
5646
5647    Once this has found the correct level for the new element,
5648    it calls output_init_element.  */
5649
5650 void
5651 process_init_element (tree value)
5652 {
5653   tree orig_value = value;
5654   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
5655
5656   designator_depth = 0;
5657   designator_errorneous = 0;
5658
5659   /* Handle superfluous braces around string cst as in
5660      char x[] = {"foo"}; */
5661   if (string_flag
5662       && constructor_type
5663       && TREE_CODE (constructor_type) == ARRAY_TYPE
5664       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
5665       && integer_zerop (constructor_unfilled_index))
5666     {
5667       if (constructor_stack->replacement_value)
5668         error_init ("excess elements in char array initializer");
5669       constructor_stack->replacement_value = value;
5670       return;
5671     }
5672
5673   if (constructor_stack->replacement_value != 0)
5674     {
5675       error_init ("excess elements in struct initializer");
5676       return;
5677     }
5678
5679   /* Ignore elements of a brace group if it is entirely superfluous
5680      and has already been diagnosed.  */
5681   if (constructor_type == 0)
5682     return;
5683
5684   /* If we've exhausted any levels that didn't have braces,
5685      pop them now.  */
5686   while (constructor_stack->implicit)
5687     {
5688       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5689            || TREE_CODE (constructor_type) == UNION_TYPE)
5690           && constructor_fields == 0)
5691         process_init_element (pop_init_level (1));
5692       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5693                && (constructor_max_index == 0
5694                    || tree_int_cst_lt (constructor_max_index,
5695                                        constructor_index)))
5696         process_init_element (pop_init_level (1));
5697       else
5698         break;
5699     }
5700
5701   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
5702   if (constructor_range_stack)
5703     {
5704       /* If value is a compound literal and we'll be just using its
5705          content, don't put it into a SAVE_EXPR.  */
5706       if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
5707           || !require_constant_value
5708           || flag_isoc99)
5709         value = save_expr (value);
5710     }
5711
5712   while (1)
5713     {
5714       if (TREE_CODE (constructor_type) == RECORD_TYPE)
5715         {
5716           tree fieldtype;
5717           enum tree_code fieldcode;
5718
5719           if (constructor_fields == 0)
5720             {
5721               pedwarn_init ("excess elements in struct initializer");
5722               break;
5723             }
5724
5725           fieldtype = TREE_TYPE (constructor_fields);
5726           if (fieldtype != error_mark_node)
5727             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5728           fieldcode = TREE_CODE (fieldtype);
5729
5730           /* Error for non-static initialization of a flexible array member.  */
5731           if (fieldcode == ARRAY_TYPE
5732               && !require_constant_value
5733               && TYPE_SIZE (fieldtype) == NULL_TREE
5734               && TREE_CHAIN (constructor_fields) == NULL_TREE)
5735             {
5736               error_init ("non-static initialization of a flexible array member");
5737               break;
5738             }
5739
5740           /* Accept a string constant to initialize a subarray.  */
5741           if (value != 0
5742               && fieldcode == ARRAY_TYPE
5743               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5744               && string_flag)
5745             value = orig_value;
5746           /* Otherwise, if we have come to a subaggregate,
5747              and we don't have an element of its type, push into it.  */
5748           else if (value != 0 && !constructor_no_implicit
5749                    && value != error_mark_node
5750                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5751                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5752                        || fieldcode == UNION_TYPE))
5753             {
5754               push_init_level (1);
5755               continue;
5756             }
5757
5758           if (value)
5759             {
5760               push_member_name (constructor_fields);
5761               output_init_element (value, fieldtype, constructor_fields, 1);
5762               RESTORE_SPELLING_DEPTH (constructor_depth);
5763             }
5764           else
5765             /* Do the bookkeeping for an element that was
5766                directly output as a constructor.  */
5767             {
5768               /* For a record, keep track of end position of last field.  */
5769               if (DECL_SIZE (constructor_fields))
5770                 constructor_bit_index
5771                   = size_binop (PLUS_EXPR,
5772                                 bit_position (constructor_fields),
5773                                 DECL_SIZE (constructor_fields));
5774
5775               /* If the current field was the first one not yet written out,
5776                  it isn't now, so update.  */
5777               if (constructor_unfilled_fields == constructor_fields)
5778                 {
5779                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5780                   /* Skip any nameless bit fields.  */
5781                   while (constructor_unfilled_fields != 0
5782                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5783                          && DECL_NAME (constructor_unfilled_fields) == 0)
5784                     constructor_unfilled_fields =
5785                       TREE_CHAIN (constructor_unfilled_fields);
5786                 }
5787             }
5788
5789           constructor_fields = TREE_CHAIN (constructor_fields);
5790           /* Skip any nameless bit fields at the beginning.  */
5791           while (constructor_fields != 0
5792                  && DECL_C_BIT_FIELD (constructor_fields)
5793                  && DECL_NAME (constructor_fields) == 0)
5794             constructor_fields = TREE_CHAIN (constructor_fields);
5795         }
5796       else if (TREE_CODE (constructor_type) == UNION_TYPE)
5797         {
5798           tree fieldtype;
5799           enum tree_code fieldcode;
5800
5801           if (constructor_fields == 0)
5802             {
5803               pedwarn_init ("excess elements in union initializer");
5804               break;
5805             }
5806
5807           fieldtype = TREE_TYPE (constructor_fields);
5808           if (fieldtype != error_mark_node)
5809             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5810           fieldcode = TREE_CODE (fieldtype);
5811
5812           /* Warn that traditional C rejects initialization of unions.
5813              We skip the warning if the value is zero.  This is done
5814              under the assumption that the zero initializer in user
5815              code appears conditioned on e.g. __STDC__ to avoid
5816              "missing initializer" warnings and relies on default
5817              initialization to zero in the traditional C case.
5818              We also skip the warning if the initializer is designated,
5819              again on the assumption that this must be conditional on
5820              __STDC__ anyway (and we've already complained about the
5821              member-designator already).  */
5822           if (warn_traditional && !in_system_header && !constructor_designated
5823               && !(value && (integer_zerop (value) || real_zerop (value))))
5824             warning ("traditional C rejects initialization of unions");
5825
5826           /* Accept a string constant to initialize a subarray.  */
5827           if (value != 0
5828               && fieldcode == ARRAY_TYPE
5829               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5830               && string_flag)
5831             value = orig_value;
5832           /* Otherwise, if we have come to a subaggregate,
5833              and we don't have an element of its type, push into it.  */
5834           else if (value != 0 && !constructor_no_implicit
5835                    && value != error_mark_node
5836                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5837                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5838                        || fieldcode == UNION_TYPE))
5839             {
5840               push_init_level (1);
5841               continue;
5842             }
5843
5844           if (value)
5845             {
5846               push_member_name (constructor_fields);
5847               output_init_element (value, fieldtype, constructor_fields, 1);
5848               RESTORE_SPELLING_DEPTH (constructor_depth);
5849             }
5850           else
5851             /* Do the bookkeeping for an element that was
5852                directly output as a constructor.  */
5853             {
5854               constructor_bit_index = DECL_SIZE (constructor_fields);
5855               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5856             }
5857
5858           constructor_fields = 0;
5859         }
5860       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5861         {
5862           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5863           enum tree_code eltcode = TREE_CODE (elttype);
5864
5865           /* Accept a string constant to initialize a subarray.  */
5866           if (value != 0
5867               && eltcode == ARRAY_TYPE
5868               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
5869               && string_flag)
5870             value = orig_value;
5871           /* Otherwise, if we have come to a subaggregate,
5872              and we don't have an element of its type, push into it.  */
5873           else if (value != 0 && !constructor_no_implicit
5874                    && value != error_mark_node
5875                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
5876                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
5877                        || eltcode == UNION_TYPE))
5878             {
5879               push_init_level (1);
5880               continue;
5881             }
5882
5883           if (constructor_max_index != 0
5884               && (tree_int_cst_lt (constructor_max_index, constructor_index)
5885                   || integer_all_onesp (constructor_max_index)))
5886             {
5887               pedwarn_init ("excess elements in array initializer");
5888               break;
5889             }
5890
5891           /* Now output the actual element.  */
5892           if (value)
5893             {
5894               push_array_bounds (tree_low_cst (constructor_index, 0));
5895               output_init_element (value, elttype, constructor_index, 1);
5896               RESTORE_SPELLING_DEPTH (constructor_depth);
5897             }
5898
5899           constructor_index
5900             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
5901
5902           if (! value)
5903             /* If we are doing the bookkeeping for an element that was
5904                directly output as a constructor, we must update
5905                constructor_unfilled_index.  */
5906             constructor_unfilled_index = constructor_index;
5907         }
5908       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5909         {
5910           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5911
5912          /* Do a basic check of initializer size.  Note that vectors
5913             always have a fixed size derived from their type.  */
5914           if (tree_int_cst_lt (constructor_max_index, constructor_index))
5915             {
5916               pedwarn_init ("excess elements in vector initializer");
5917               break;
5918             }
5919
5920           /* Now output the actual element.  */
5921           if (value)
5922             output_init_element (value, elttype, constructor_index, 1);
5923
5924           constructor_index
5925             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
5926
5927           if (! value)
5928             /* If we are doing the bookkeeping for an element that was
5929                directly output as a constructor, we must update
5930                constructor_unfilled_index.  */
5931             constructor_unfilled_index = constructor_index;
5932         }
5933
5934       /* Handle the sole element allowed in a braced initializer
5935          for a scalar variable.  */
5936       else if (constructor_fields == 0)
5937         {
5938           pedwarn_init ("excess elements in scalar initializer");
5939           break;
5940         }
5941       else
5942         {
5943           if (value)
5944             output_init_element (value, constructor_type, NULL_TREE, 1);
5945           constructor_fields = 0;
5946         }
5947
5948       /* Handle range initializers either at this level or anywhere higher
5949          in the designator stack.  */
5950       if (constructor_range_stack)
5951         {
5952           struct constructor_range_stack *p, *range_stack;
5953           int finish = 0;
5954
5955           range_stack = constructor_range_stack;
5956           constructor_range_stack = 0;
5957           while (constructor_stack != range_stack->stack)
5958             {
5959               if (!constructor_stack->implicit)
5960                 abort ();
5961               process_init_element (pop_init_level (1));
5962             }
5963           for (p = range_stack;
5964                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
5965                p = p->prev)
5966             {
5967               if (!constructor_stack->implicit)
5968                 abort ();
5969               process_init_element (pop_init_level (1));
5970             }
5971
5972           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
5973           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
5974             finish = 1;
5975
5976           while (1)
5977             {
5978               constructor_index = p->index;
5979               constructor_fields = p->fields;
5980               if (finish && p->range_end && p->index == p->range_start)
5981                 {
5982                   finish = 0;
5983                   p->prev = 0;
5984                 }
5985               p = p->next;
5986               if (!p)
5987                 break;
5988               push_init_level (2);
5989               p->stack = constructor_stack;
5990               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
5991                 p->index = p->range_start;
5992             }
5993
5994           if (!finish)
5995             constructor_range_stack = range_stack;
5996           continue;
5997         }
5998
5999       break;
6000     }
6001
6002   constructor_range_stack = 0;
6003 }
6004 \f
6005 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6006    (guaranteed to be 'volatile' or null) and ARGS (represented using
6007    an ASM_STMT node).  */
6008 tree
6009 build_asm_stmt (tree cv_qualifier, tree args)
6010 {
6011   if (!TREE_OPERAND (args, 0))
6012     TREE_OPERAND (args, 0) = cv_qualifier;
6013   return add_stmt (args);
6014 }
6015
6016 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6017    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
6018    SIMPLE indicates whether there was anything at all after the
6019    string in the asm expression -- asm("blah") and asm("blah" : )
6020    are subtly different.  We use a ASM_STMT node to represent this.  */
6021 tree
6022 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6023                 bool simple)
6024 {
6025   tree tail;
6026   tree args;
6027
6028   /* We can remove output conversions that change the type,
6029      but not the mode.  */
6030   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6031     {
6032       tree output = TREE_VALUE (tail);
6033
6034       STRIP_NOPS (output);
6035       TREE_VALUE (tail) = output;
6036
6037       /* Allow conversions as LHS here.  build_modify_expr as called below
6038          will do the right thing with them.  */
6039       while (TREE_CODE (output) == NOP_EXPR
6040              || TREE_CODE (output) == CONVERT_EXPR
6041              || TREE_CODE (output) == FLOAT_EXPR
6042              || TREE_CODE (output) == FIX_TRUNC_EXPR
6043              || TREE_CODE (output) == FIX_FLOOR_EXPR
6044              || TREE_CODE (output) == FIX_ROUND_EXPR
6045              || TREE_CODE (output) == FIX_CEIL_EXPR)
6046         output = TREE_OPERAND (output, 0);
6047
6048       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6049     }
6050
6051   /* Remove output conversions that change the type but not the mode.  */
6052   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6053     {
6054       tree output = TREE_VALUE (tail);
6055       STRIP_NOPS (output);
6056       TREE_VALUE (tail) = output;
6057     }
6058
6059   /* Perform default conversions on array and function inputs.
6060      Don't do this for other types as it would screw up operands
6061      expected to be in memory.  */
6062   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6063     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6064
6065   args = build_stmt (ASM_STMT, 0, string, outputs, inputs, clobbers);
6066
6067   /* Simple asm statements are treated as volatile.  */
6068   if (simple)
6069     {
6070       TREE_OPERAND (args, 0) = ridpointers[RID_VOLATILE];
6071       ASM_INPUT_P (args) = 1;
6072     }
6073   return args;
6074 }
6075
6076 /* Expand an ASM statement with operands, handling output operands
6077    that are not variables or INDIRECT_REFS by transforming such
6078    cases into cases that expand_asm_operands can handle.
6079
6080    Arguments are same as for expand_asm_operands.  */
6081
6082 void
6083 c_expand_asm_operands (tree string, tree outputs, tree inputs,
6084                        tree clobbers, int vol, location_t locus)
6085 {
6086   int noutputs = list_length (outputs);
6087   int i;
6088   /* o[I] is the place that output number I should be written.  */
6089   tree *o = alloca (noutputs * sizeof (tree));
6090   tree tail;
6091
6092   /* Record the contents of OUTPUTS before it is modified.  */
6093   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6094     {
6095       o[i] = TREE_VALUE (tail);
6096       if (o[i] == error_mark_node)
6097         return;
6098     }
6099
6100   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6101      OUTPUTS some trees for where the values were actually stored.  */
6102   expand_asm_operands (string, outputs, inputs, clobbers, vol, locus);
6103
6104   /* Copy all the intermediate outputs into the specified outputs.  */
6105   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6106     {
6107       if (o[i] != TREE_VALUE (tail))
6108         {
6109           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6110                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6111           free_temp_slots ();
6112
6113           /* Restore the original value so that it's correct the next
6114              time we expand this function.  */
6115           TREE_VALUE (tail) = o[i];
6116         }
6117       /* Detect modification of read-only values.
6118          (Otherwise done by build_modify_expr.)  */
6119       else
6120         {
6121           tree type = TREE_TYPE (o[i]);
6122           if (TREE_READONLY (o[i])
6123               || TYPE_READONLY (type)
6124               || ((TREE_CODE (type) == RECORD_TYPE
6125                    || TREE_CODE (type) == UNION_TYPE)
6126                   && C_TYPE_FIELDS_READONLY (type)))
6127             readonly_warning (o[i], "modification by `asm'");
6128         }
6129     }
6130
6131   /* Those MODIFY_EXPRs could do autoincrements.  */
6132   emit_queue ();
6133 }
6134 \f
6135 /* Expand a C `return' statement.
6136    RETVAL is the expression for what to return,
6137    or a null pointer for `return;' with no value.  */
6138
6139 tree
6140 c_expand_return (tree retval)
6141 {
6142   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6143
6144   if (TREE_THIS_VOLATILE (current_function_decl))
6145     warning ("function declared `noreturn' has a `return' statement");
6146
6147   if (!retval)
6148     {
6149       current_function_returns_null = 1;
6150       if ((warn_return_type || flag_isoc99)
6151           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6152         pedwarn_c99 ("`return' with no value, in function returning non-void");
6153     }
6154   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6155     {
6156       current_function_returns_null = 1;
6157       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6158         pedwarn ("`return' with a value, in function returning void");
6159     }
6160   else
6161     {
6162       tree t = convert_for_assignment (valtype, retval, _("return"),
6163                                        NULL_TREE, NULL_TREE, 0);
6164       tree res = DECL_RESULT (current_function_decl);
6165       tree inner;
6166
6167       current_function_returns_value = 1;
6168       if (t == error_mark_node)
6169         return NULL_TREE;
6170
6171       inner = t = convert (TREE_TYPE (res), t);
6172
6173       /* Strip any conversions, additions, and subtractions, and see if
6174          we are returning the address of a local variable.  Warn if so.  */
6175       while (1)
6176         {
6177           switch (TREE_CODE (inner))
6178             {
6179             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6180             case PLUS_EXPR:
6181               inner = TREE_OPERAND (inner, 0);
6182               continue;
6183
6184             case MINUS_EXPR:
6185               /* If the second operand of the MINUS_EXPR has a pointer
6186                  type (or is converted from it), this may be valid, so
6187                  don't give a warning.  */
6188               {
6189                 tree op1 = TREE_OPERAND (inner, 1);
6190
6191                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6192                        && (TREE_CODE (op1) == NOP_EXPR
6193                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6194                            || TREE_CODE (op1) == CONVERT_EXPR))
6195                   op1 = TREE_OPERAND (op1, 0);
6196
6197                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6198                   break;
6199
6200                 inner = TREE_OPERAND (inner, 0);
6201                 continue;
6202               }
6203
6204             case ADDR_EXPR:
6205               inner = TREE_OPERAND (inner, 0);
6206
6207               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6208                 inner = TREE_OPERAND (inner, 0);
6209
6210               if (TREE_CODE (inner) == VAR_DECL
6211                   && ! DECL_EXTERNAL (inner)
6212                   && ! TREE_STATIC (inner)
6213                   && DECL_CONTEXT (inner) == current_function_decl)
6214                 warning ("function returns address of local variable");
6215               break;
6216
6217             default:
6218               break;
6219             }
6220
6221           break;
6222         }
6223
6224       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6225     }
6226
6227  return add_stmt (build_return_stmt (retval));
6228 }
6229 \f
6230 struct c_switch {
6231   /* The SWITCH_STMT being built.  */
6232   tree switch_stmt;
6233   /* A splay-tree mapping the low element of a case range to the high
6234      element, or NULL_TREE if there is no high element.  Used to
6235      determine whether or not a new case label duplicates an old case
6236      label.  We need a tree, rather than simply a hash table, because
6237      of the GNU case range extension.  */
6238   splay_tree cases;
6239   /* The next node on the stack.  */
6240   struct c_switch *next;
6241 };
6242
6243 /* A stack of the currently active switch statements.  The innermost
6244    switch statement is on the top of the stack.  There is no need to
6245    mark the stack for garbage collection because it is only active
6246    during the processing of the body of a function, and we never
6247    collect at that point.  */
6248
6249 static struct c_switch *switch_stack;
6250
6251 /* Start a C switch statement, testing expression EXP.  Return the new
6252    SWITCH_STMT.  */
6253
6254 tree
6255 c_start_case (tree exp)
6256 {
6257   enum tree_code code;
6258   tree type, orig_type = error_mark_node;
6259   struct c_switch *cs;
6260
6261   if (exp != error_mark_node)
6262     {
6263       code = TREE_CODE (TREE_TYPE (exp));
6264       orig_type = TREE_TYPE (exp);
6265
6266       if (! INTEGRAL_TYPE_P (orig_type)
6267           && code != ERROR_MARK)
6268         {
6269           error ("switch quantity not an integer");
6270           exp = integer_zero_node;
6271         }
6272       else
6273         {
6274           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6275
6276           if (warn_traditional && !in_system_header
6277               && (type == long_integer_type_node
6278                   || type == long_unsigned_type_node))
6279             warning ("`long' switch expression not converted to `int' in ISO C");
6280
6281           exp = default_conversion (exp);
6282           type = TREE_TYPE (exp);
6283         }
6284     }
6285
6286   /* Add this new SWITCH_STMT to the stack.  */
6287   cs = xmalloc (sizeof (*cs));
6288   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
6289   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6290   cs->next = switch_stack;
6291   switch_stack = cs;
6292
6293   return add_stmt (switch_stack->switch_stmt);
6294 }
6295
6296 /* Process a case label.  */
6297
6298 tree
6299 do_case (tree low_value, tree high_value)
6300 {
6301   tree label = NULL_TREE;
6302
6303   if (switch_stack)
6304     {
6305       bool switch_was_empty_p = (SWITCH_BODY (switch_stack->switch_stmt) == NULL_TREE);
6306
6307       label = c_add_case_label (switch_stack->cases,
6308                                 SWITCH_COND (switch_stack->switch_stmt),
6309                                 low_value, high_value);
6310       if (label == error_mark_node)
6311         label = NULL_TREE;
6312       else if (switch_was_empty_p)
6313         {
6314           /* Attach the first case label to the SWITCH_BODY.  */
6315           SWITCH_BODY (switch_stack->switch_stmt) = TREE_CHAIN (switch_stack->switch_stmt);
6316           TREE_CHAIN (switch_stack->switch_stmt) = NULL_TREE;
6317         }
6318     }
6319   else if (low_value)
6320     error ("case label not within a switch statement");
6321   else
6322     error ("`default' label not within a switch statement");
6323
6324   return label;
6325 }
6326
6327 /* Finish the switch statement.  */
6328
6329 void
6330 c_finish_case (void)
6331 {
6332   struct c_switch *cs = switch_stack;
6333
6334   /* Rechain the next statements to the SWITCH_STMT.  */
6335   last_tree = cs->switch_stmt;
6336
6337   /* Pop the stack.  */
6338   switch_stack = switch_stack->next;
6339   splay_tree_delete (cs->cases);
6340   free (cs);
6341 }
6342
6343 /* Build a binary-operation expression without default conversions.
6344    CODE is the kind of expression to build.
6345    This function differs from `build' in several ways:
6346    the data type of the result is computed and recorded in it,
6347    warnings are generated if arg data types are invalid,
6348    special handling for addition and subtraction of pointers is known,
6349    and some optimization is done (operations on narrow ints
6350    are done in the narrower type when that gives the same result).
6351    Constant folding is also done before the result is returned.
6352
6353    Note that the operands will never have enumeral types, or function
6354    or array types, because either they will have the default conversions
6355    performed or they have both just been converted to some other type in which
6356    the arithmetic is to be done.  */
6357
6358 tree
6359 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6360                  int convert_p)
6361 {
6362   tree type0, type1;
6363   enum tree_code code0, code1;
6364   tree op0, op1;
6365
6366   /* Expression code to give to the expression when it is built.
6367      Normally this is CODE, which is what the caller asked for,
6368      but in some special cases we change it.  */
6369   enum tree_code resultcode = code;
6370
6371   /* Data type in which the computation is to be performed.
6372      In the simplest cases this is the common type of the arguments.  */
6373   tree result_type = NULL;
6374
6375   /* Nonzero means operands have already been type-converted
6376      in whatever way is necessary.
6377      Zero means they need to be converted to RESULT_TYPE.  */
6378   int converted = 0;
6379
6380   /* Nonzero means create the expression with this type, rather than
6381      RESULT_TYPE.  */
6382   tree build_type = 0;
6383
6384   /* Nonzero means after finally constructing the expression
6385      convert it to this type.  */
6386   tree final_type = 0;
6387
6388   /* Nonzero if this is an operation like MIN or MAX which can
6389      safely be computed in short if both args are promoted shorts.
6390      Also implies COMMON.
6391      -1 indicates a bitwise operation; this makes a difference
6392      in the exact conditions for when it is safe to do the operation
6393      in a narrower mode.  */
6394   int shorten = 0;
6395
6396   /* Nonzero if this is a comparison operation;
6397      if both args are promoted shorts, compare the original shorts.
6398      Also implies COMMON.  */
6399   int short_compare = 0;
6400
6401   /* Nonzero if this is a right-shift operation, which can be computed on the
6402      original short and then promoted if the operand is a promoted short.  */
6403   int short_shift = 0;
6404
6405   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
6406   int common = 0;
6407
6408   if (convert_p)
6409     {
6410       op0 = default_conversion (orig_op0);
6411       op1 = default_conversion (orig_op1);
6412     }
6413   else
6414     {
6415       op0 = orig_op0;
6416       op1 = orig_op1;
6417     }
6418
6419   type0 = TREE_TYPE (op0);
6420   type1 = TREE_TYPE (op1);
6421
6422   /* The expression codes of the data types of the arguments tell us
6423      whether the arguments are integers, floating, pointers, etc.  */
6424   code0 = TREE_CODE (type0);
6425   code1 = TREE_CODE (type1);
6426
6427   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
6428   STRIP_TYPE_NOPS (op0);
6429   STRIP_TYPE_NOPS (op1);
6430
6431   /* If an error was already reported for one of the arguments,
6432      avoid reporting another error.  */
6433
6434   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6435     return error_mark_node;
6436
6437   switch (code)
6438     {
6439     case PLUS_EXPR:
6440       /* Handle the pointer + int case.  */
6441       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6442         return pointer_int_sum (PLUS_EXPR, op0, op1);
6443       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
6444         return pointer_int_sum (PLUS_EXPR, op1, op0);
6445       else
6446         common = 1;
6447       break;
6448
6449     case MINUS_EXPR:
6450       /* Subtraction of two similar pointers.
6451          We must subtract them as integers, then divide by object size.  */
6452       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
6453           && comp_target_types (type0, type1, 1))
6454         return pointer_diff (op0, op1);
6455       /* Handle pointer minus int.  Just like pointer plus int.  */
6456       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6457         return pointer_int_sum (MINUS_EXPR, op0, op1);
6458       else
6459         common = 1;
6460       break;
6461
6462     case MULT_EXPR:
6463       common = 1;
6464       break;
6465
6466     case TRUNC_DIV_EXPR:
6467     case CEIL_DIV_EXPR:
6468     case FLOOR_DIV_EXPR:
6469     case ROUND_DIV_EXPR:
6470     case EXACT_DIV_EXPR:
6471       /* Floating point division by zero is a legitimate way to obtain
6472          infinities and NaNs.  */
6473       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6474         warning ("division by zero");
6475
6476       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6477            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6478           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6479               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
6480         {
6481           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
6482             resultcode = RDIV_EXPR;
6483           else
6484             /* Although it would be tempting to shorten always here, that
6485                loses on some targets, since the modulo instruction is
6486                undefined if the quotient can't be represented in the
6487                computation mode.  We shorten only if unsigned or if
6488                dividing by something we know != -1.  */
6489             shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6490                        || (TREE_CODE (op1) == INTEGER_CST
6491                            && ! integer_all_onesp (op1)));
6492           common = 1;
6493         }
6494       break;
6495
6496     case BIT_AND_EXPR:
6497     case BIT_IOR_EXPR:
6498     case BIT_XOR_EXPR:
6499       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6500         shorten = -1;
6501       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
6502         common = 1;
6503       break;
6504
6505     case TRUNC_MOD_EXPR:
6506     case FLOOR_MOD_EXPR:
6507       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6508         warning ("division by zero");
6509
6510       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6511         {
6512           /* Although it would be tempting to shorten always here, that loses
6513              on some targets, since the modulo instruction is undefined if the
6514              quotient can't be represented in the computation mode.  We shorten
6515              only if unsigned or if dividing by something we know != -1.  */
6516           shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6517                      || (TREE_CODE (op1) == INTEGER_CST
6518                          && ! integer_all_onesp (op1)));
6519           common = 1;
6520         }
6521       break;
6522
6523     case TRUTH_ANDIF_EXPR:
6524     case TRUTH_ORIF_EXPR:
6525     case TRUTH_AND_EXPR:
6526     case TRUTH_OR_EXPR:
6527     case TRUTH_XOR_EXPR:
6528       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
6529            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
6530           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
6531               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
6532         {
6533           /* Result of these operations is always an int,
6534              but that does not mean the operands should be
6535              converted to ints!  */
6536           result_type = integer_type_node;
6537           op0 = (*lang_hooks.truthvalue_conversion) (op0);
6538           op1 = (*lang_hooks.truthvalue_conversion) (op1);
6539           converted = 1;
6540         }
6541       break;
6542
6543       /* Shift operations: result has same type as first operand;
6544          always convert second operand to int.
6545          Also set SHORT_SHIFT if shifting rightward.  */
6546
6547     case RSHIFT_EXPR:
6548       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6549         {
6550           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6551             {
6552               if (tree_int_cst_sgn (op1) < 0)
6553                 warning ("right shift count is negative");
6554               else
6555                 {
6556                   if (! integer_zerop (op1))
6557                     short_shift = 1;
6558
6559                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6560                     warning ("right shift count >= width of type");
6561                 }
6562             }
6563
6564           /* Use the type of the value to be shifted.  */
6565           result_type = type0;
6566           /* Convert the shift-count to an integer, regardless of size
6567              of value being shifted.  */
6568           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6569             op1 = convert (integer_type_node, op1);
6570           /* Avoid converting op1 to result_type later.  */
6571           converted = 1;
6572         }
6573       break;
6574
6575     case LSHIFT_EXPR:
6576       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6577         {
6578           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6579             {
6580               if (tree_int_cst_sgn (op1) < 0)
6581                 warning ("left shift count is negative");
6582
6583               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6584                 warning ("left shift count >= width of type");
6585             }
6586
6587           /* Use the type of the value to be shifted.  */
6588           result_type = type0;
6589           /* Convert the shift-count to an integer, regardless of size
6590              of value being shifted.  */
6591           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6592             op1 = convert (integer_type_node, op1);
6593           /* Avoid converting op1 to result_type later.  */
6594           converted = 1;
6595         }
6596       break;
6597
6598     case RROTATE_EXPR:
6599     case LROTATE_EXPR:
6600       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6601         {
6602           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6603             {
6604               if (tree_int_cst_sgn (op1) < 0)
6605                 warning ("shift count is negative");
6606               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6607                 warning ("shift count >= width of type");
6608             }
6609
6610           /* Use the type of the value to be shifted.  */
6611           result_type = type0;
6612           /* Convert the shift-count to an integer, regardless of size
6613              of value being shifted.  */
6614           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6615             op1 = convert (integer_type_node, op1);
6616           /* Avoid converting op1 to result_type later.  */
6617           converted = 1;
6618         }
6619       break;
6620
6621     case EQ_EXPR:
6622     case NE_EXPR:
6623       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
6624         warning ("comparing floating point with == or != is unsafe");
6625       /* Result of comparison is always int,
6626          but don't convert the args to int!  */
6627       build_type = integer_type_node;
6628       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6629            || code0 == COMPLEX_TYPE
6630            || code0 == VECTOR_TYPE)
6631           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6632               || code1 == COMPLEX_TYPE
6633               || code1 == VECTOR_TYPE))
6634         short_compare = 1;
6635       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6636         {
6637           tree tt0 = TREE_TYPE (type0);
6638           tree tt1 = TREE_TYPE (type1);
6639           /* Anything compares with void *.  void * compares with anything.
6640              Otherwise, the targets must be compatible
6641              and both must be object or both incomplete.  */
6642           if (comp_target_types (type0, type1, 1))
6643             result_type = common_type (type0, type1);
6644           else if (VOID_TYPE_P (tt0))
6645             {
6646               /* op0 != orig_op0 detects the case of something
6647                  whose value is 0 but which isn't a valid null ptr const.  */
6648               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
6649                   && TREE_CODE (tt1) == FUNCTION_TYPE)
6650                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6651             }
6652           else if (VOID_TYPE_P (tt1))
6653             {
6654               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
6655                   && TREE_CODE (tt0) == FUNCTION_TYPE)
6656                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6657             }
6658           else
6659             pedwarn ("comparison of distinct pointer types lacks a cast");
6660
6661           if (result_type == NULL_TREE)
6662             result_type = ptr_type_node;
6663         }
6664       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6665                && integer_zerop (op1))
6666         result_type = type0;
6667       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6668                && integer_zerop (op0))
6669         result_type = type1;
6670       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6671         {
6672           result_type = type0;
6673           pedwarn ("comparison between pointer and integer");
6674         }
6675       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6676         {
6677           result_type = type1;
6678           pedwarn ("comparison between pointer and integer");
6679         }
6680       break;
6681
6682     case MAX_EXPR:
6683     case MIN_EXPR:
6684       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6685           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6686         shorten = 1;
6687       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6688         {
6689           if (comp_target_types (type0, type1, 1))
6690             {
6691               result_type = common_type (type0, type1);
6692               if (pedantic
6693                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6694                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6695             }
6696           else
6697             {
6698               result_type = ptr_type_node;
6699               pedwarn ("comparison of distinct pointer types lacks a cast");
6700             }
6701         }
6702       break;
6703
6704     case LE_EXPR:
6705     case GE_EXPR:
6706     case LT_EXPR:
6707     case GT_EXPR:
6708       build_type = integer_type_node;
6709       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6710           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6711         short_compare = 1;
6712       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6713         {
6714           if (comp_target_types (type0, type1, 1))
6715             {
6716               result_type = common_type (type0, type1);
6717               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
6718                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
6719                 pedwarn ("comparison of complete and incomplete pointers");
6720               else if (pedantic
6721                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6722                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6723             }
6724           else
6725             {
6726               result_type = ptr_type_node;
6727               pedwarn ("comparison of distinct pointer types lacks a cast");
6728             }
6729         }
6730       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6731                && integer_zerop (op1))
6732         {
6733           result_type = type0;
6734           if (pedantic || extra_warnings)
6735             pedwarn ("ordered comparison of pointer with integer zero");
6736         }
6737       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6738                && integer_zerop (op0))
6739         {
6740           result_type = type1;
6741           if (pedantic)
6742             pedwarn ("ordered comparison of pointer with integer zero");
6743         }
6744       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6745         {
6746           result_type = type0;
6747           pedwarn ("comparison between pointer and integer");
6748         }
6749       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6750         {
6751           result_type = type1;
6752           pedwarn ("comparison between pointer and integer");
6753         }
6754       break;
6755
6756     case UNORDERED_EXPR:
6757     case ORDERED_EXPR:
6758     case UNLT_EXPR:
6759     case UNLE_EXPR:
6760     case UNGT_EXPR:
6761     case UNGE_EXPR:
6762     case UNEQ_EXPR:
6763       build_type = integer_type_node;
6764       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
6765         {
6766           error ("unordered comparison on non-floating point argument");
6767           return error_mark_node;
6768         }
6769       common = 1;
6770       break;
6771
6772     default:
6773       break;
6774     }
6775
6776   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6777     return error_mark_node;
6778
6779   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
6780        || code0 == VECTOR_TYPE)
6781       &&
6782       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
6783        || code1 == VECTOR_TYPE))
6784     {
6785       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
6786
6787       if (shorten || common || short_compare)
6788         result_type = common_type (type0, type1);
6789
6790       /* For certain operations (which identify themselves by shorten != 0)
6791          if both args were extended from the same smaller type,
6792          do the arithmetic in that type and then extend.
6793
6794          shorten !=0 and !=1 indicates a bitwise operation.
6795          For them, this optimization is safe only if
6796          both args are zero-extended or both are sign-extended.
6797          Otherwise, we might change the result.
6798          Eg, (short)-1 | (unsigned short)-1 is (int)-1
6799          but calculated in (unsigned short) it would be (unsigned short)-1.  */
6800
6801       if (shorten && none_complex)
6802         {
6803           int unsigned0, unsigned1;
6804           tree arg0 = get_narrower (op0, &unsigned0);
6805           tree arg1 = get_narrower (op1, &unsigned1);
6806           /* UNS is 1 if the operation to be done is an unsigned one.  */
6807           int uns = TREE_UNSIGNED (result_type);
6808           tree type;
6809
6810           final_type = result_type;
6811
6812           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
6813              but it *requires* conversion to FINAL_TYPE.  */
6814
6815           if ((TYPE_PRECISION (TREE_TYPE (op0))
6816                == TYPE_PRECISION (TREE_TYPE (arg0)))
6817               && TREE_TYPE (op0) != final_type)
6818             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
6819           if ((TYPE_PRECISION (TREE_TYPE (op1))
6820                == TYPE_PRECISION (TREE_TYPE (arg1)))
6821               && TREE_TYPE (op1) != final_type)
6822             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
6823
6824           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
6825
6826           /* For bitwise operations, signedness of nominal type
6827              does not matter.  Consider only how operands were extended.  */
6828           if (shorten == -1)
6829             uns = unsigned0;
6830
6831           /* Note that in all three cases below we refrain from optimizing
6832              an unsigned operation on sign-extended args.
6833              That would not be valid.  */
6834
6835           /* Both args variable: if both extended in same way
6836              from same width, do it in that width.
6837              Do it unsigned if args were zero-extended.  */
6838           if ((TYPE_PRECISION (TREE_TYPE (arg0))
6839                < TYPE_PRECISION (result_type))
6840               && (TYPE_PRECISION (TREE_TYPE (arg1))
6841                   == TYPE_PRECISION (TREE_TYPE (arg0)))
6842               && unsigned0 == unsigned1
6843               && (unsigned0 || !uns))
6844             result_type
6845               = c_common_signed_or_unsigned_type
6846               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
6847           else if (TREE_CODE (arg0) == INTEGER_CST
6848                    && (unsigned1 || !uns)
6849                    && (TYPE_PRECISION (TREE_TYPE (arg1))
6850                        < TYPE_PRECISION (result_type))
6851                    && (type
6852                        = c_common_signed_or_unsigned_type (unsigned1,
6853                                                            TREE_TYPE (arg1)),
6854                        int_fits_type_p (arg0, type)))
6855             result_type = type;
6856           else if (TREE_CODE (arg1) == INTEGER_CST
6857                    && (unsigned0 || !uns)
6858                    && (TYPE_PRECISION (TREE_TYPE (arg0))
6859                        < TYPE_PRECISION (result_type))
6860                    && (type
6861                        = c_common_signed_or_unsigned_type (unsigned0,
6862                                                            TREE_TYPE (arg0)),
6863                        int_fits_type_p (arg1, type)))
6864             result_type = type;
6865         }
6866
6867       /* Shifts can be shortened if shifting right.  */
6868
6869       if (short_shift)
6870         {
6871           int unsigned_arg;
6872           tree arg0 = get_narrower (op0, &unsigned_arg);
6873
6874           final_type = result_type;
6875
6876           if (arg0 == op0 && final_type == TREE_TYPE (op0))
6877             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
6878
6879           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
6880               /* We can shorten only if the shift count is less than the
6881                  number of bits in the smaller type size.  */
6882               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
6883               /* We cannot drop an unsigned shift after sign-extension.  */
6884               && (!TREE_UNSIGNED (final_type) || unsigned_arg))
6885             {
6886               /* Do an unsigned shift if the operand was zero-extended.  */
6887               result_type
6888                 = c_common_signed_or_unsigned_type (unsigned_arg,
6889                                                     TREE_TYPE (arg0));
6890               /* Convert value-to-be-shifted to that type.  */
6891               if (TREE_TYPE (op0) != result_type)
6892                 op0 = convert (result_type, op0);
6893               converted = 1;
6894             }
6895         }
6896
6897       /* Comparison operations are shortened too but differently.
6898          They identify themselves by setting short_compare = 1.  */
6899
6900       if (short_compare)
6901         {
6902           /* Don't write &op0, etc., because that would prevent op0
6903              from being kept in a register.
6904              Instead, make copies of the our local variables and
6905              pass the copies by reference, then copy them back afterward.  */
6906           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
6907           enum tree_code xresultcode = resultcode;
6908           tree val
6909             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
6910
6911           if (val != 0)
6912             return val;
6913
6914           op0 = xop0, op1 = xop1;
6915           converted = 1;
6916           resultcode = xresultcode;
6917
6918           if (warn_sign_compare && skip_evaluation == 0)
6919             {
6920               int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
6921               int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
6922               int unsignedp0, unsignedp1;
6923               tree primop0 = get_narrower (op0, &unsignedp0);
6924               tree primop1 = get_narrower (op1, &unsignedp1);
6925
6926               xop0 = orig_op0;
6927               xop1 = orig_op1;
6928               STRIP_TYPE_NOPS (xop0);
6929               STRIP_TYPE_NOPS (xop1);
6930
6931               /* Give warnings for comparisons between signed and unsigned
6932                  quantities that may fail.
6933
6934                  Do the checking based on the original operand trees, so that
6935                  casts will be considered, but default promotions won't be.
6936
6937                  Do not warn if the comparison is being done in a signed type,
6938                  since the signed type will only be chosen if it can represent
6939                  all the values of the unsigned type.  */
6940               if (! TREE_UNSIGNED (result_type))
6941                 /* OK */;
6942               /* Do not warn if both operands are the same signedness.  */
6943               else if (op0_signed == op1_signed)
6944                 /* OK */;
6945               else
6946                 {
6947                   tree sop, uop;
6948
6949                   if (op0_signed)
6950                     sop = xop0, uop = xop1;
6951                   else
6952                     sop = xop1, uop = xop0;
6953
6954                   /* Do not warn if the signed quantity is an
6955                      unsuffixed integer literal (or some static
6956                      constant expression involving such literals or a
6957                      conditional expression involving such literals)
6958                      and it is non-negative.  */
6959                   if (c_tree_expr_nonnegative_p (sop))
6960                     /* OK */;
6961                   /* Do not warn if the comparison is an equality operation,
6962                      the unsigned quantity is an integral constant, and it
6963                      would fit in the result if the result were signed.  */
6964                   else if (TREE_CODE (uop) == INTEGER_CST
6965                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
6966                            && int_fits_type_p
6967                            (uop, c_common_signed_type (result_type)))
6968                     /* OK */;
6969                   /* Do not warn if the unsigned quantity is an enumeration
6970                      constant and its maximum value would fit in the result
6971                      if the result were signed.  */
6972                   else if (TREE_CODE (uop) == INTEGER_CST
6973                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
6974                            && int_fits_type_p
6975                            (TYPE_MAX_VALUE (TREE_TYPE(uop)),
6976                             c_common_signed_type (result_type)))
6977                     /* OK */;
6978                   else
6979                     warning ("comparison between signed and unsigned");
6980                 }
6981
6982               /* Warn if two unsigned values are being compared in a size
6983                  larger than their original size, and one (and only one) is the
6984                  result of a `~' operator.  This comparison will always fail.
6985
6986                  Also warn if one operand is a constant, and the constant
6987                  does not have all bits set that are set in the ~ operand
6988                  when it is extended.  */
6989
6990               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
6991                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
6992                 {
6993                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
6994                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
6995                                             &unsignedp0);
6996                   else
6997                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
6998                                             &unsignedp1);
6999
7000                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7001                     {
7002                       tree primop;
7003                       HOST_WIDE_INT constant, mask;
7004                       int unsignedp, bits;
7005
7006                       if (host_integerp (primop0, 0))
7007                         {
7008                           primop = primop1;
7009                           unsignedp = unsignedp1;
7010                           constant = tree_low_cst (primop0, 0);
7011                         }
7012                       else
7013                         {
7014                           primop = primop0;
7015                           unsignedp = unsignedp0;
7016                           constant = tree_low_cst (primop1, 0);
7017                         }
7018
7019                       bits = TYPE_PRECISION (TREE_TYPE (primop));
7020                       if (bits < TYPE_PRECISION (result_type)
7021                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7022                         {
7023                           mask = (~ (HOST_WIDE_INT) 0) << bits;
7024                           if ((mask & constant) != mask)
7025                             warning ("comparison of promoted ~unsigned with constant");
7026                         }
7027                     }
7028                   else if (unsignedp0 && unsignedp1
7029                            && (TYPE_PRECISION (TREE_TYPE (primop0))
7030                                < TYPE_PRECISION (result_type))
7031                            && (TYPE_PRECISION (TREE_TYPE (primop1))
7032                                < TYPE_PRECISION (result_type)))
7033                     warning ("comparison of promoted ~unsigned with unsigned");
7034                 }
7035             }
7036         }
7037     }
7038
7039   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7040      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7041      Then the expression will be built.
7042      It will be given type FINAL_TYPE if that is nonzero;
7043      otherwise, it will be given type RESULT_TYPE.  */
7044
7045   if (!result_type)
7046     {
7047       binary_op_error (code);
7048       return error_mark_node;
7049     }
7050
7051   if (! converted)
7052     {
7053       if (TREE_TYPE (op0) != result_type)
7054         op0 = convert (result_type, op0);
7055       if (TREE_TYPE (op1) != result_type)
7056         op1 = convert (result_type, op1);
7057     }
7058
7059   if (build_type == NULL_TREE)
7060     build_type = result_type;
7061
7062   {
7063     tree result = build (resultcode, build_type, op0, op1);
7064     tree folded;
7065
7066     /* Treat expressions in initializers specially as they can't trap.  */
7067     folded = initializer_stack ? fold_initializer (result)
7068                                : fold (result);
7069     if (folded == result)
7070       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
7071     if (final_type != 0)
7072       return convert (final_type, folded);
7073     return folded;
7074   }
7075 }
7076