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