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)
2050           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2051               || code1 == COMPLEX_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       break;
2075
2076     case TRUNC_MOD_EXPR:
2077     case FLOOR_MOD_EXPR:
2078       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
2079         warning ("division by zero");
2080
2081       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2082         {
2083           /* Although it would be tempting to shorten always here, that loses
2084              on some targets, since the modulo instruction is undefined if the
2085              quotient can't be represented in the computation mode.  We shorten
2086              only if unsigned or if dividing by something we know != -1.  */
2087           shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2088                      || (TREE_CODE (op1) == INTEGER_CST
2089                          && ! integer_all_onesp (op1)));
2090           common = 1;
2091         }
2092       break;
2093
2094     case TRUTH_ANDIF_EXPR:
2095     case TRUTH_ORIF_EXPR:
2096     case TRUTH_AND_EXPR:
2097     case TRUTH_OR_EXPR:
2098     case TRUTH_XOR_EXPR:
2099       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2100            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2101           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2102               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2103         {
2104           /* Result of these operations is always an int,
2105              but that does not mean the operands should be
2106              converted to ints!  */
2107           result_type = integer_type_node;
2108           op0 = c_common_truthvalue_conversion (op0);
2109           op1 = c_common_truthvalue_conversion (op1);
2110           converted = 1;
2111         }
2112       break;
2113
2114       /* Shift operations: result has same type as first operand;
2115          always convert second operand to int.
2116          Also set SHORT_SHIFT if shifting rightward.  */
2117
2118     case RSHIFT_EXPR:
2119       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2120         {
2121           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2122             {
2123               if (tree_int_cst_sgn (op1) < 0)
2124                 warning ("right shift count is negative");
2125               else
2126                 {
2127                   if (! integer_zerop (op1))
2128                     short_shift = 1;
2129
2130                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2131                     warning ("right shift count >= width of type");
2132                 }
2133             }
2134
2135           /* Use the type of the value to be shifted.  */
2136           result_type = type0;
2137           /* Convert the shift-count to an integer, regardless of size
2138              of value being shifted.  */
2139           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2140             op1 = convert (integer_type_node, op1);
2141           /* Avoid converting op1 to result_type later.  */
2142           converted = 1;
2143         }
2144       break;
2145
2146     case LSHIFT_EXPR:
2147       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2148         {
2149           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2150             {
2151               if (tree_int_cst_sgn (op1) < 0)
2152                 warning ("left shift count is negative");
2153
2154               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2155                 warning ("left shift count >= width of type");
2156             }
2157
2158           /* Use the type of the value to be shifted.  */
2159           result_type = type0;
2160           /* Convert the shift-count to an integer, regardless of size
2161              of value being shifted.  */
2162           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2163             op1 = convert (integer_type_node, op1);
2164           /* Avoid converting op1 to result_type later.  */
2165           converted = 1;
2166         }
2167       break;
2168
2169     case RROTATE_EXPR:
2170     case LROTATE_EXPR:
2171       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2172         {
2173           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2174             {
2175               if (tree_int_cst_sgn (op1) < 0)
2176                 warning ("shift count is negative");
2177               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2178                 warning ("shift count >= width of type");
2179             }
2180
2181           /* Use the type of the value to be shifted.  */
2182           result_type = type0;
2183           /* Convert the shift-count to an integer, regardless of size
2184              of value being shifted.  */
2185           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2186             op1 = convert (integer_type_node, op1);
2187           /* Avoid converting op1 to result_type later.  */
2188           converted = 1;
2189         }
2190       break;
2191
2192     case EQ_EXPR:
2193     case NE_EXPR:
2194       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2195         warning ("comparing floating point with == or != is unsafe");
2196       /* Result of comparison is always int,
2197          but don't convert the args to int!  */
2198       build_type = integer_type_node;
2199       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2200            || code0 == COMPLEX_TYPE)
2201           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2202               || code1 == COMPLEX_TYPE))
2203         short_compare = 1;
2204       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2205         {
2206           tree tt0 = TREE_TYPE (type0);
2207           tree tt1 = TREE_TYPE (type1);
2208           /* Anything compares with void *.  void * compares with anything.
2209              Otherwise, the targets must be compatible
2210              and both must be object or both incomplete.  */
2211           if (comp_target_types (type0, type1))
2212             result_type = common_type (type0, type1);
2213           else if (VOID_TYPE_P (tt0))
2214             {
2215               /* op0 != orig_op0 detects the case of something
2216                  whose value is 0 but which isn't a valid null ptr const.  */
2217               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2218                   && TREE_CODE (tt1) == FUNCTION_TYPE)
2219                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2220             }
2221           else if (VOID_TYPE_P (tt1))
2222             {
2223               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2224                   && TREE_CODE (tt0) == FUNCTION_TYPE)
2225                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2226             }
2227           else
2228             pedwarn ("comparison of distinct pointer types lacks a cast");
2229
2230           if (result_type == NULL_TREE)
2231             result_type = ptr_type_node;
2232         }
2233       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2234                && integer_zerop (op1))
2235         result_type = type0;
2236       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2237                && integer_zerop (op0))
2238         result_type = type1;
2239       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2240         {
2241           result_type = type0;
2242           pedwarn ("comparison between pointer and integer");
2243         }
2244       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2245         {
2246           result_type = type1;
2247           pedwarn ("comparison between pointer and integer");
2248         }
2249       break;
2250
2251     case MAX_EXPR:
2252     case MIN_EXPR:
2253       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2254           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2255         shorten = 1;
2256       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2257         {
2258           if (comp_target_types (type0, type1))
2259             {
2260               result_type = common_type (type0, type1);
2261               if (pedantic
2262                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2263                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2264             }
2265           else
2266             {
2267               result_type = ptr_type_node;
2268               pedwarn ("comparison of distinct pointer types lacks a cast");
2269             }
2270         }
2271       break;
2272
2273     case LE_EXPR:
2274     case GE_EXPR:
2275     case LT_EXPR:
2276     case GT_EXPR:
2277       build_type = integer_type_node;
2278       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2279           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2280         short_compare = 1;
2281       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2282         {
2283           if (comp_target_types (type0, type1))
2284             {
2285               result_type = common_type (type0, type1);
2286               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2287                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2288                 pedwarn ("comparison of complete and incomplete pointers");
2289               else if (pedantic
2290                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2291                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2292             }
2293           else
2294             {
2295               result_type = ptr_type_node;
2296               pedwarn ("comparison of distinct pointer types lacks a cast");
2297             }
2298         }
2299       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2300                && integer_zerop (op1))
2301         {
2302           result_type = type0;
2303           if (pedantic || extra_warnings)
2304             pedwarn ("ordered comparison of pointer with integer zero");
2305         }
2306       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2307                && integer_zerop (op0))
2308         {
2309           result_type = type1;
2310           if (pedantic)
2311             pedwarn ("ordered comparison of pointer with integer zero");
2312         }
2313       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2314         {
2315           result_type = type0;
2316           pedwarn ("comparison between pointer and integer");
2317         }
2318       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2319         {
2320           result_type = type1;
2321           pedwarn ("comparison between pointer and integer");
2322         }
2323       break;
2324
2325     case UNORDERED_EXPR:
2326     case ORDERED_EXPR:
2327     case UNLT_EXPR:
2328     case UNLE_EXPR:
2329     case UNGT_EXPR:
2330     case UNGE_EXPR:
2331     case UNEQ_EXPR:
2332       build_type = integer_type_node;
2333       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2334         {
2335           error ("unordered comparison on non-floating point argument");
2336           return error_mark_node;
2337         }
2338       common = 1;
2339       break;
2340
2341     default:
2342       break;
2343     }
2344
2345   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2346       &&
2347       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2348     {
2349       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2350
2351       if (shorten || common || short_compare)
2352         result_type = common_type (type0, type1);
2353
2354       /* For certain operations (which identify themselves by shorten != 0)
2355          if both args were extended from the same smaller type,
2356          do the arithmetic in that type and then extend.
2357
2358          shorten !=0 and !=1 indicates a bitwise operation.
2359          For them, this optimization is safe only if
2360          both args are zero-extended or both are sign-extended.
2361          Otherwise, we might change the result.
2362          Eg, (short)-1 | (unsigned short)-1 is (int)-1
2363          but calculated in (unsigned short) it would be (unsigned short)-1.  */
2364
2365       if (shorten && none_complex)
2366         {
2367           int unsigned0, unsigned1;
2368           tree arg0 = get_narrower (op0, &unsigned0);
2369           tree arg1 = get_narrower (op1, &unsigned1);
2370           /* UNS is 1 if the operation to be done is an unsigned one.  */
2371           int uns = TREE_UNSIGNED (result_type);
2372           tree type;
2373
2374           final_type = result_type;
2375
2376           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2377              but it *requires* conversion to FINAL_TYPE.  */
2378
2379           if ((TYPE_PRECISION (TREE_TYPE (op0))
2380                == TYPE_PRECISION (TREE_TYPE (arg0)))
2381               && TREE_TYPE (op0) != final_type)
2382             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2383           if ((TYPE_PRECISION (TREE_TYPE (op1))
2384                == TYPE_PRECISION (TREE_TYPE (arg1)))
2385               && TREE_TYPE (op1) != final_type)
2386             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2387
2388           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
2389
2390           /* For bitwise operations, signedness of nominal type
2391              does not matter.  Consider only how operands were extended.  */
2392           if (shorten == -1)
2393             uns = unsigned0;
2394
2395           /* Note that in all three cases below we refrain from optimizing
2396              an unsigned operation on sign-extended args.
2397              That would not be valid.  */
2398
2399           /* Both args variable: if both extended in same way
2400              from same width, do it in that width.
2401              Do it unsigned if args were zero-extended.  */
2402           if ((TYPE_PRECISION (TREE_TYPE (arg0))
2403                < TYPE_PRECISION (result_type))
2404               && (TYPE_PRECISION (TREE_TYPE (arg1))
2405                   == TYPE_PRECISION (TREE_TYPE (arg0)))
2406               && unsigned0 == unsigned1
2407               && (unsigned0 || !uns))
2408             result_type
2409               = c_common_signed_or_unsigned_type
2410               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2411           else if (TREE_CODE (arg0) == INTEGER_CST
2412                    && (unsigned1 || !uns)
2413                    && (TYPE_PRECISION (TREE_TYPE (arg1))
2414                        < TYPE_PRECISION (result_type))
2415                    && (type
2416                        = c_common_signed_or_unsigned_type (unsigned1,
2417                                                            TREE_TYPE (arg1)),
2418                        int_fits_type_p (arg0, type)))
2419             result_type = type;
2420           else if (TREE_CODE (arg1) == INTEGER_CST
2421                    && (unsigned0 || !uns)
2422                    && (TYPE_PRECISION (TREE_TYPE (arg0))
2423                        < TYPE_PRECISION (result_type))
2424                    && (type
2425                        = c_common_signed_or_unsigned_type (unsigned0,
2426                                                            TREE_TYPE (arg0)),
2427                        int_fits_type_p (arg1, type)))
2428             result_type = type;
2429         }
2430
2431       /* Shifts can be shortened if shifting right.  */
2432
2433       if (short_shift)
2434         {
2435           int unsigned_arg;
2436           tree arg0 = get_narrower (op0, &unsigned_arg);
2437
2438           final_type = result_type;
2439
2440           if (arg0 == op0 && final_type == TREE_TYPE (op0))
2441             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2442
2443           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2444               /* We can shorten only if the shift count is less than the
2445                  number of bits in the smaller type size.  */
2446               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2447               /* We cannot drop an unsigned shift after sign-extension.  */
2448               && (!TREE_UNSIGNED (final_type) || unsigned_arg))
2449             {
2450               /* Do an unsigned shift if the operand was zero-extended.  */
2451               result_type
2452                 = c_common_signed_or_unsigned_type (unsigned_arg,
2453                                                     TREE_TYPE (arg0));
2454               /* Convert value-to-be-shifted to that type.  */
2455               if (TREE_TYPE (op0) != result_type)
2456                 op0 = convert (result_type, op0);
2457               converted = 1;
2458             }
2459         }
2460
2461       /* Comparison operations are shortened too but differently.
2462          They identify themselves by setting short_compare = 1.  */
2463
2464       if (short_compare)
2465         {
2466           /* Don't write &op0, etc., because that would prevent op0
2467              from being kept in a register.
2468              Instead, make copies of the our local variables and
2469              pass the copies by reference, then copy them back afterward.  */
2470           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2471           enum tree_code xresultcode = resultcode;
2472           tree val
2473             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2474
2475           if (val != 0)
2476             return val;
2477
2478           op0 = xop0, op1 = xop1;
2479           converted = 1;
2480           resultcode = xresultcode;
2481
2482           if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2483               && skip_evaluation == 0)
2484             {
2485               int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2486               int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2487               int unsignedp0, unsignedp1;
2488               tree primop0 = get_narrower (op0, &unsignedp0);
2489               tree primop1 = get_narrower (op1, &unsignedp1);
2490
2491               xop0 = orig_op0;
2492               xop1 = orig_op1;
2493               STRIP_TYPE_NOPS (xop0);
2494               STRIP_TYPE_NOPS (xop1);
2495
2496               /* Give warnings for comparisons between signed and unsigned
2497                  quantities that may fail.
2498
2499                  Do the checking based on the original operand trees, so that
2500                  casts will be considered, but default promotions won't be.
2501
2502                  Do not warn if the comparison is being done in a signed type,
2503                  since the signed type will only be chosen if it can represent
2504                  all the values of the unsigned type.  */
2505               if (! TREE_UNSIGNED (result_type))
2506                 /* OK */;
2507               /* Do not warn if both operands are the same signedness.  */
2508               else if (op0_signed == op1_signed)
2509                 /* OK */;
2510               else
2511                 {
2512                   tree sop, uop;
2513
2514                   if (op0_signed)
2515                     sop = xop0, uop = xop1;
2516                   else
2517                     sop = xop1, uop = xop0;
2518
2519                   /* Do not warn if the signed quantity is an
2520                      unsuffixed integer literal (or some static
2521                      constant expression involving such literals or a
2522                      conditional expression involving such literals)
2523                      and it is non-negative.  */
2524                   if (tree_expr_nonnegative_p (sop))
2525                     /* OK */;
2526                   /* Do not warn if the comparison is an equality operation,
2527                      the unsigned quantity is an integral constant, and it
2528                      would fit in the result if the result were signed.  */
2529                   else if (TREE_CODE (uop) == INTEGER_CST
2530                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2531                            && int_fits_type_p
2532                            (uop, c_common_signed_type (result_type)))
2533                     /* OK */;
2534                   /* Do not warn if the unsigned quantity is an enumeration
2535                      constant and its maximum value would fit in the result
2536                      if the result were signed.  */
2537                   else if (TREE_CODE (uop) == INTEGER_CST
2538                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2539                            && int_fits_type_p
2540                            (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2541                             c_common_signed_type (result_type)))
2542                     /* OK */;
2543                   else
2544                     warning ("comparison between signed and unsigned");
2545                 }
2546
2547               /* Warn if two unsigned values are being compared in a size
2548                  larger than their original size, and one (and only one) is the
2549                  result of a `~' operator.  This comparison will always fail.
2550
2551                  Also warn if one operand is a constant, and the constant
2552                  does not have all bits set that are set in the ~ operand
2553                  when it is extended.  */
2554
2555               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2556                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2557                 {
2558                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2559                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2560                                             &unsignedp0);
2561                   else
2562                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2563                                             &unsignedp1);
2564
2565                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2566                     {
2567                       tree primop;
2568                       HOST_WIDE_INT constant, mask;
2569                       int unsignedp, bits;
2570
2571                       if (host_integerp (primop0, 0))
2572                         {
2573                           primop = primop1;
2574                           unsignedp = unsignedp1;
2575                           constant = tree_low_cst (primop0, 0);
2576                         }
2577                       else
2578                         {
2579                           primop = primop0;
2580                           unsignedp = unsignedp0;
2581                           constant = tree_low_cst (primop1, 0);
2582                         }
2583
2584                       bits = TYPE_PRECISION (TREE_TYPE (primop));
2585                       if (bits < TYPE_PRECISION (result_type)
2586                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2587                         {
2588                           mask = (~ (HOST_WIDE_INT) 0) << bits;
2589                           if ((mask & constant) != mask)
2590                             warning ("comparison of promoted ~unsigned with constant");
2591                         }
2592                     }
2593                   else if (unsignedp0 && unsignedp1
2594                            && (TYPE_PRECISION (TREE_TYPE (primop0))
2595                                < TYPE_PRECISION (result_type))
2596                            && (TYPE_PRECISION (TREE_TYPE (primop1))
2597                                < TYPE_PRECISION (result_type)))
2598                     warning ("comparison of promoted ~unsigned with unsigned");
2599                 }
2600             }
2601         }
2602     }
2603
2604   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2605      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2606      Then the expression will be built.
2607      It will be given type FINAL_TYPE if that is nonzero;
2608      otherwise, it will be given type RESULT_TYPE.  */
2609
2610   if (!result_type)
2611     {
2612       binary_op_error (code);
2613       return error_mark_node;
2614     }
2615
2616   if (! converted)
2617     {
2618       if (TREE_TYPE (op0) != result_type)
2619         op0 = convert (result_type, op0);
2620       if (TREE_TYPE (op1) != result_type)
2621         op1 = convert (result_type, op1);
2622     }
2623
2624   if (build_type == NULL_TREE)
2625     build_type = result_type;
2626
2627   {
2628     tree result = build (resultcode, build_type, op0, op1);
2629     tree folded;
2630
2631     folded = fold (result);
2632     if (folded == result)
2633       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2634     if (final_type != 0)
2635       return convert (final_type, folded);
2636     return folded;
2637   }
2638 }
2639 \f
2640 /* Return a tree for the difference of pointers OP0 and OP1.
2641    The resulting tree has type int.  */
2642
2643 static tree
2644 pointer_diff (op0, op1)
2645      tree op0, op1;
2646 {
2647   tree result, folded;
2648   tree restype = ptrdiff_type_node;
2649
2650   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2651   tree con0, con1, lit0, lit1;
2652   tree orig_op1 = op1;
2653
2654   if (pedantic || warn_pointer_arith)
2655     {
2656       if (TREE_CODE (target_type) == VOID_TYPE)
2657         pedwarn ("pointer of type `void *' used in subtraction");
2658       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2659         pedwarn ("pointer to a function used in subtraction");
2660     }
2661
2662   /* If the conversion to ptrdiff_type does anything like widening or
2663      converting a partial to an integral mode, we get a convert_expression
2664      that is in the way to do any simplifications.
2665      (fold-const.c doesn't know that the extra bits won't be needed.
2666      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2667      different mode in place.)
2668      So first try to find a common term here 'by hand'; we want to cover
2669      at least the cases that occur in legal static initializers.  */
2670   con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2671   con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2672
2673   if (TREE_CODE (con0) == PLUS_EXPR)
2674     {
2675       lit0 = TREE_OPERAND (con0, 1);
2676       con0 = TREE_OPERAND (con0, 0);
2677     }
2678   else
2679     lit0 = integer_zero_node;
2680
2681   if (TREE_CODE (con1) == PLUS_EXPR)
2682     {
2683       lit1 = TREE_OPERAND (con1, 1);
2684       con1 = TREE_OPERAND (con1, 0);
2685     }
2686   else
2687     lit1 = integer_zero_node;
2688
2689   if (operand_equal_p (con0, con1, 0))
2690     {
2691       op0 = lit0;
2692       op1 = lit1;
2693     }
2694
2695
2696   /* First do the subtraction as integers;
2697      then drop through to build the divide operator.
2698      Do not do default conversions on the minus operator
2699      in case restype is a short type.  */
2700
2701   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2702                          convert (restype, op1), 0);
2703   /* This generates an error if op1 is pointer to incomplete type.  */
2704   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2705     error ("arithmetic on pointer to an incomplete type");
2706
2707   /* This generates an error if op0 is pointer to incomplete type.  */
2708   op1 = c_size_in_bytes (target_type);
2709
2710   /* Divide by the size, in easiest possible way.  */
2711
2712   result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2713
2714   folded = fold (result);
2715   if (folded == result)
2716     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2717   return folded;
2718 }
2719 \f
2720 /* Construct and perhaps optimize a tree representation
2721    for a unary operation.  CODE, a tree_code, specifies the operation
2722    and XARG is the operand.
2723    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2724    the default promotions (such as from short to int).
2725    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2726    allows non-lvalues; this is only used to handle conversion of non-lvalue
2727    arrays to pointers in C99.  */
2728
2729 tree
2730 build_unary_op (code, xarg, flag)
2731      enum tree_code code;
2732      tree xarg;
2733      int flag;
2734 {
2735   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2736   tree arg = xarg;
2737   tree argtype = 0;
2738   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2739   tree val;
2740   int noconvert = flag;
2741
2742   if (typecode == ERROR_MARK)
2743     return error_mark_node;
2744   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2745     typecode = INTEGER_TYPE;
2746
2747   switch (code)
2748     {
2749     case CONVERT_EXPR:
2750       /* This is used for unary plus, because a CONVERT_EXPR
2751          is enough to prevent anybody from looking inside for
2752          associativity, but won't generate any code.  */
2753       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2754             || typecode == COMPLEX_TYPE))
2755         {
2756           error ("wrong type argument to unary plus");
2757           return error_mark_node;
2758         }
2759       else if (!noconvert)
2760         arg = default_conversion (arg);
2761       arg = non_lvalue (arg);
2762       break;
2763
2764     case NEGATE_EXPR:
2765       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2766             || typecode == COMPLEX_TYPE))
2767         {
2768           error ("wrong type argument to unary minus");
2769           return error_mark_node;
2770         }
2771       else if (!noconvert)
2772         arg = default_conversion (arg);
2773       break;
2774
2775     case BIT_NOT_EXPR:
2776       if (typecode == COMPLEX_TYPE)
2777         {
2778           code = CONJ_EXPR;
2779           if (pedantic)
2780             pedwarn ("ISO C does not support `~' for complex conjugation");
2781           if (!noconvert)
2782             arg = default_conversion (arg);
2783         }
2784       else if (typecode != INTEGER_TYPE)
2785         {
2786           error ("wrong type argument to bit-complement");
2787           return error_mark_node;
2788         }
2789       else if (!noconvert)
2790         arg = default_conversion (arg);
2791       break;
2792
2793     case ABS_EXPR:
2794       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2795             || typecode == COMPLEX_TYPE))
2796         {
2797           error ("wrong type argument to abs");
2798           return error_mark_node;
2799         }
2800       else if (!noconvert)
2801         arg = default_conversion (arg);
2802       break;
2803
2804     case CONJ_EXPR:
2805       /* Conjugating a real value is a no-op, but allow it anyway.  */
2806       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2807             || typecode == COMPLEX_TYPE))
2808         {
2809           error ("wrong type argument to conjugation");
2810           return error_mark_node;
2811         }
2812       else if (!noconvert)
2813         arg = default_conversion (arg);
2814       break;
2815
2816     case TRUTH_NOT_EXPR:
2817       if (typecode != INTEGER_TYPE
2818           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2819           && typecode != COMPLEX_TYPE
2820           /* These will convert to a pointer.  */
2821           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2822         {
2823           error ("wrong type argument to unary exclamation mark");
2824           return error_mark_node;
2825         }
2826       arg = c_common_truthvalue_conversion (arg);
2827       return invert_truthvalue (arg);
2828
2829     case NOP_EXPR:
2830       break;
2831
2832     case REALPART_EXPR:
2833       if (TREE_CODE (arg) == COMPLEX_CST)
2834         return TREE_REALPART (arg);
2835       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2836         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2837       else
2838         return arg;
2839
2840     case IMAGPART_EXPR:
2841       if (TREE_CODE (arg) == COMPLEX_CST)
2842         return TREE_IMAGPART (arg);
2843       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2844         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2845       else
2846         return convert (TREE_TYPE (arg), integer_zero_node);
2847
2848     case PREINCREMENT_EXPR:
2849     case POSTINCREMENT_EXPR:
2850     case PREDECREMENT_EXPR:
2851     case POSTDECREMENT_EXPR:
2852       /* Handle complex lvalues (when permitted)
2853          by reduction to simpler cases.  */
2854
2855       val = unary_complex_lvalue (code, arg, 0);
2856       if (val != 0)
2857         return val;
2858
2859       /* Increment or decrement the real part of the value,
2860          and don't change the imaginary part.  */
2861       if (typecode == COMPLEX_TYPE)
2862         {
2863           tree real, imag;
2864
2865           if (pedantic)
2866             pedwarn ("ISO C does not support `++' and `--' on complex types");
2867
2868           arg = stabilize_reference (arg);
2869           real = build_unary_op (REALPART_EXPR, arg, 1);
2870           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2871           return build (COMPLEX_EXPR, TREE_TYPE (arg),
2872                         build_unary_op (code, real, 1), imag);
2873         }
2874
2875       /* Report invalid types.  */
2876
2877       if (typecode != POINTER_TYPE
2878           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2879         {
2880           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2881             error ("wrong type argument to increment");
2882           else
2883             error ("wrong type argument to decrement");
2884
2885           return error_mark_node;
2886         }
2887
2888       {
2889         tree inc;
2890         tree result_type = TREE_TYPE (arg);
2891
2892         arg = get_unwidened (arg, 0);
2893         argtype = TREE_TYPE (arg);
2894
2895         /* Compute the increment.  */
2896
2897         if (typecode == POINTER_TYPE)
2898           {
2899             /* If pointer target is an undefined struct,
2900                we just cannot know how to do the arithmetic.  */
2901             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2902               {
2903                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2904                   error ("increment of pointer to unknown structure");
2905                 else
2906                   error ("decrement of pointer to unknown structure");
2907               }
2908             else if ((pedantic || warn_pointer_arith)
2909                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2910                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2911               {
2912                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2913                   pedwarn ("wrong type argument to increment");
2914                 else
2915                   pedwarn ("wrong type argument to decrement");
2916               }
2917
2918             inc = c_size_in_bytes (TREE_TYPE (result_type));
2919           }
2920         else
2921           inc = integer_one_node;
2922
2923         inc = convert (argtype, inc);
2924
2925         /* Handle incrementing a cast-expression.  */
2926
2927         while (1)
2928           switch (TREE_CODE (arg))
2929             {
2930             case NOP_EXPR:
2931             case CONVERT_EXPR:
2932             case FLOAT_EXPR:
2933             case FIX_TRUNC_EXPR:
2934             case FIX_FLOOR_EXPR:
2935             case FIX_ROUND_EXPR:
2936             case FIX_CEIL_EXPR:
2937               pedantic_lvalue_warning (CONVERT_EXPR);
2938               /* If the real type has the same machine representation
2939                  as the type it is cast to, we can make better output
2940                  by adding directly to the inside of the cast.  */
2941               if ((TREE_CODE (TREE_TYPE (arg))
2942                    == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2943                   && (TYPE_MODE (TREE_TYPE (arg))
2944                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2945                 arg = TREE_OPERAND (arg, 0);
2946               else
2947                 {
2948                   tree incremented, modify, value;
2949                   if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2950                     value = boolean_increment (code, arg);
2951                   else
2952                     {
2953                       arg = stabilize_reference (arg);
2954                       if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2955                         value = arg;
2956                       else
2957                         value = save_expr (arg);
2958                       incremented = build (((code == PREINCREMENT_EXPR
2959                                              || code == POSTINCREMENT_EXPR)
2960                                             ? PLUS_EXPR : MINUS_EXPR),
2961                                            argtype, value, inc);
2962                       TREE_SIDE_EFFECTS (incremented) = 1;
2963                       modify = build_modify_expr (arg, NOP_EXPR, incremented);
2964                       value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2965                     }
2966                   TREE_USED (value) = 1;
2967                   return value;
2968                 }
2969               break;
2970
2971             default:
2972               goto give_up;
2973             }
2974       give_up:
2975
2976         /* Complain about anything else that is not a true lvalue.  */
2977         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2978                                     || code == POSTINCREMENT_EXPR)
2979                                    ? "invalid lvalue in increment"
2980                                    : "invalid lvalue in decrement")))
2981           return error_mark_node;
2982
2983         /* Report a read-only lvalue.  */
2984         if (TREE_READONLY (arg))
2985           readonly_warning (arg,
2986                             ((code == PREINCREMENT_EXPR
2987                               || code == POSTINCREMENT_EXPR)
2988                              ? "increment" : "decrement"));
2989
2990         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2991           val = boolean_increment (code, arg);
2992         else
2993           val = build (code, TREE_TYPE (arg), arg, inc);
2994         TREE_SIDE_EFFECTS (val) = 1;
2995         val = convert (result_type, val);
2996         if (TREE_CODE (val) != code)
2997           TREE_NO_UNUSED_WARNING (val) = 1;
2998         return val;
2999       }
3000
3001     case ADDR_EXPR:
3002       /* Note that this operation never does default_conversion.  */
3003
3004       /* Let &* cancel out to simplify resulting code.  */
3005       if (TREE_CODE (arg) == INDIRECT_REF)
3006         {
3007           /* Don't let this be an lvalue.  */
3008           if (lvalue_p (TREE_OPERAND (arg, 0)))
3009             return non_lvalue (TREE_OPERAND (arg, 0));
3010           return TREE_OPERAND (arg, 0);
3011         }
3012
3013       /* For &x[y], return x+y */
3014       if (TREE_CODE (arg) == ARRAY_REF)
3015         {
3016           if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
3017             return error_mark_node;
3018           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3019                                   TREE_OPERAND (arg, 1), 1);
3020         }
3021
3022       /* Handle complex lvalues (when permitted)
3023          by reduction to simpler cases.  */
3024       val = unary_complex_lvalue (code, arg, flag);
3025       if (val != 0)
3026         return val;
3027
3028 #if 0 /* Turned off because inconsistent;
3029          float f; *&(int)f = 3.4 stores in int format
3030          whereas (int)f = 3.4 stores in float format.  */
3031       /* Address of a cast is just a cast of the address
3032          of the operand of the cast.  */
3033       switch (TREE_CODE (arg))
3034         {
3035         case NOP_EXPR:
3036         case CONVERT_EXPR:
3037         case FLOAT_EXPR:
3038         case FIX_TRUNC_EXPR:
3039         case FIX_FLOOR_EXPR:
3040         case FIX_ROUND_EXPR:
3041         case FIX_CEIL_EXPR:
3042           if (pedantic)
3043             pedwarn ("ISO C forbids the address of a cast expression");
3044           return convert (build_pointer_type (TREE_TYPE (arg)),
3045                           build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3046                                           0));
3047         }
3048 #endif
3049
3050       /* Anything not already handled and not a true memory reference
3051          or a non-lvalue array is an error.  */
3052       else if (typecode != FUNCTION_TYPE && !flag
3053                && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3054         return error_mark_node;
3055
3056       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
3057       argtype = TREE_TYPE (arg);
3058
3059       /* If the lvalue is const or volatile, merge that into the type
3060          to which the address will point.  Note that you can't get a
3061          restricted pointer by taking the address of something, so we
3062          only have to deal with `const' and `volatile' here.  */
3063       if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3064           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3065           argtype = c_build_type_variant (argtype,
3066                                           TREE_READONLY (arg),
3067                                           TREE_THIS_VOLATILE (arg));
3068
3069       argtype = build_pointer_type (argtype);
3070
3071       if (!c_mark_addressable (arg))
3072         return error_mark_node;
3073
3074       {
3075         tree addr;
3076
3077         if (TREE_CODE (arg) == COMPONENT_REF)
3078           {
3079             tree field = TREE_OPERAND (arg, 1);
3080
3081             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
3082
3083             if (DECL_C_BIT_FIELD (field))
3084               {
3085                 error ("attempt to take address of bit-field structure member `%s'",
3086                        IDENTIFIER_POINTER (DECL_NAME (field)));
3087                 return error_mark_node;
3088               }
3089
3090             addr = fold (build (PLUS_EXPR, argtype,
3091                                 convert (argtype, addr),
3092                                 convert (argtype, byte_position (field))));
3093           }
3094         else
3095           addr = build1 (code, argtype, arg);
3096
3097         /* Address of a static or external variable or
3098            file-scope function counts as a constant.  */
3099         if (staticp (arg)
3100             && ! (TREE_CODE (arg) == FUNCTION_DECL
3101                   && DECL_CONTEXT (arg) != 0))
3102           TREE_CONSTANT (addr) = 1;
3103         return addr;
3104       }
3105
3106     default:
3107       break;
3108     }
3109
3110   if (argtype == 0)
3111     argtype = TREE_TYPE (arg);
3112   return fold (build1 (code, argtype, arg));
3113 }
3114
3115 #if 0
3116 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3117    convert ARG with the same conversions in the same order
3118    and return the result.  */
3119
3120 static tree
3121 convert_sequence (conversions, arg)
3122      tree conversions;
3123      tree arg;
3124 {
3125   switch (TREE_CODE (conversions))
3126     {
3127     case NOP_EXPR:
3128     case CONVERT_EXPR:
3129     case FLOAT_EXPR:
3130     case FIX_TRUNC_EXPR:
3131     case FIX_FLOOR_EXPR:
3132     case FIX_ROUND_EXPR:
3133     case FIX_CEIL_EXPR:
3134       return convert (TREE_TYPE (conversions),
3135                       convert_sequence (TREE_OPERAND (conversions, 0),
3136                                         arg));
3137
3138     default:
3139       return arg;
3140     }
3141 }
3142 #endif /* 0 */
3143
3144 /* Return nonzero if REF is an lvalue valid for this language.
3145    Lvalues can be assigned, unless their type has TYPE_READONLY.
3146    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
3147
3148 int
3149 lvalue_p (ref)
3150      tree ref;
3151 {
3152   enum tree_code code = TREE_CODE (ref);
3153
3154   switch (code)
3155     {
3156     case REALPART_EXPR:
3157     case IMAGPART_EXPR:
3158     case COMPONENT_REF:
3159       return lvalue_p (TREE_OPERAND (ref, 0));
3160
3161     case COMPOUND_LITERAL_EXPR:
3162     case STRING_CST:
3163       return 1;
3164
3165     case INDIRECT_REF:
3166     case ARRAY_REF:
3167     case VAR_DECL:
3168     case PARM_DECL:
3169     case RESULT_DECL:
3170     case ERROR_MARK:
3171       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3172               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3173
3174     case BIND_EXPR:
3175     case RTL_EXPR:
3176       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3177
3178     default:
3179       return 0;
3180     }
3181 }
3182
3183 /* Return nonzero if REF is an lvalue valid for this language;
3184    otherwise, print an error message and return zero.  */
3185
3186 int
3187 lvalue_or_else (ref, msgid)
3188      tree ref;
3189      const char *msgid;
3190 {
3191   int win = lvalue_p (ref);
3192
3193   if (! win)
3194     error ("%s", msgid);
3195
3196   return win;
3197 }
3198
3199 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3200    for certain kinds of expressions which are not really lvalues
3201    but which we can accept as lvalues.  If FLAG is nonzero, then
3202    non-lvalues are OK since we may be converting a non-lvalue array to
3203    a pointer in C99.
3204
3205    If ARG is not a kind of expression we can handle, return zero.  */
3206
3207 static tree
3208 unary_complex_lvalue (code, arg, flag)
3209      enum tree_code code;
3210      tree arg;
3211      int flag;
3212 {
3213   /* Handle (a, b) used as an "lvalue".  */
3214   if (TREE_CODE (arg) == COMPOUND_EXPR)
3215     {
3216       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3217
3218       /* If this returns a function type, it isn't really being used as
3219          an lvalue, so don't issue a warning about it.  */
3220       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3221         pedantic_lvalue_warning (COMPOUND_EXPR);
3222
3223       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3224                     TREE_OPERAND (arg, 0), real_result);
3225     }
3226
3227   /* Handle (a ? b : c) used as an "lvalue".  */
3228   if (TREE_CODE (arg) == COND_EXPR)
3229     {
3230       if (!flag)
3231         pedantic_lvalue_warning (COND_EXPR);
3232       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3233         pedantic_lvalue_warning (COMPOUND_EXPR);
3234
3235       return (build_conditional_expr
3236               (TREE_OPERAND (arg, 0),
3237                build_unary_op (code, TREE_OPERAND (arg, 1), flag),
3238                build_unary_op (code, TREE_OPERAND (arg, 2), flag)));
3239     }
3240
3241   return 0;
3242 }
3243
3244 /* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
3245    COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
3246
3247 static void
3248 pedantic_lvalue_warning (code)
3249      enum tree_code code;
3250 {
3251   if (pedantic)
3252     switch (code)
3253       {
3254       case COND_EXPR:
3255         pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3256         break;
3257       case COMPOUND_EXPR:
3258         pedwarn ("ISO C forbids use of compound expressions as lvalues");
3259         break;
3260       default:
3261         pedwarn ("ISO C forbids use of cast expressions as lvalues");
3262         break;
3263       }
3264 }
3265 \f
3266 /* Warn about storing in something that is `const'.  */
3267
3268 void
3269 readonly_warning (arg, msgid)
3270      tree arg;
3271      const char *msgid;
3272 {
3273   if (TREE_CODE (arg) == COMPONENT_REF)
3274     {
3275       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3276         readonly_warning (TREE_OPERAND (arg, 0), msgid);
3277       else
3278         pedwarn ("%s of read-only member `%s'", _(msgid),
3279                  IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3280     }
3281   else if (TREE_CODE (arg) == VAR_DECL)
3282     pedwarn ("%s of read-only variable `%s'", _(msgid),
3283              IDENTIFIER_POINTER (DECL_NAME (arg)));
3284   else
3285     pedwarn ("%s of read-only location", _(msgid));
3286 }
3287 \f
3288 /* Mark EXP saying that we need to be able to take the
3289    address of it; it should not be allocated in a register.
3290    Returns true if successful.  */
3291
3292 bool
3293 c_mark_addressable (exp)
3294      tree exp;
3295 {
3296   tree x = exp;
3297
3298   while (1)
3299     switch (TREE_CODE (x))
3300       {
3301       case COMPONENT_REF:
3302         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3303           {
3304             error ("cannot take address of bit-field `%s'",
3305                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3306             return false;
3307           }
3308
3309         /* ... fall through ...  */
3310
3311       case ADDR_EXPR:
3312       case ARRAY_REF:
3313       case REALPART_EXPR:
3314       case IMAGPART_EXPR:
3315         x = TREE_OPERAND (x, 0);
3316         break;
3317
3318       case COMPOUND_LITERAL_EXPR:
3319       case CONSTRUCTOR:
3320         TREE_ADDRESSABLE (x) = 1;
3321         return true;
3322
3323       case VAR_DECL:
3324       case CONST_DECL:
3325       case PARM_DECL:
3326       case RESULT_DECL:
3327         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3328             && DECL_NONLOCAL (x))
3329           {
3330             if (TREE_PUBLIC (x))
3331               {
3332                 error ("global register variable `%s' used in nested function",
3333                        IDENTIFIER_POINTER (DECL_NAME (x)));
3334                 return false;
3335               }
3336             pedwarn ("register variable `%s' used in nested function",
3337                      IDENTIFIER_POINTER (DECL_NAME (x)));
3338           }
3339         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3340           {
3341             if (TREE_PUBLIC (x))
3342               {
3343                 error ("address of global register variable `%s' requested",
3344                        IDENTIFIER_POINTER (DECL_NAME (x)));
3345                 return false;
3346               }
3347
3348             /* If we are making this addressable due to its having
3349                volatile components, give a different error message.  Also
3350                handle the case of an unnamed parameter by not trying
3351                to give the name.  */
3352
3353             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3354               {
3355                 error ("cannot put object with volatile field into register");
3356                 return false;
3357               }
3358
3359             pedwarn ("address of register variable `%s' requested",
3360                      IDENTIFIER_POINTER (DECL_NAME (x)));
3361           }
3362         put_var_into_stack (x);
3363
3364         /* drops in */
3365       case FUNCTION_DECL:
3366         TREE_ADDRESSABLE (x) = 1;
3367 #if 0  /* poplevel deals with this now.  */
3368         if (DECL_CONTEXT (x) == 0)
3369           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3370 #endif
3371
3372       default:
3373         return true;
3374     }
3375 }
3376 \f
3377 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
3378
3379 tree
3380 build_conditional_expr (ifexp, op1, op2)
3381      tree ifexp, op1, op2;
3382 {
3383   tree type1;
3384   tree type2;
3385   enum tree_code code1;
3386   enum tree_code code2;
3387   tree result_type = NULL;
3388   tree orig_op1 = op1, orig_op2 = op2;
3389
3390   ifexp = c_common_truthvalue_conversion (default_conversion (ifexp));
3391
3392 #if 0 /* Produces wrong result if within sizeof.  */
3393   /* Don't promote the operands separately if they promote
3394      the same way.  Return the unpromoted type and let the combined
3395      value get promoted if necessary.  */
3396
3397   if (TREE_TYPE (op1) == TREE_TYPE (op2)
3398       && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3399       && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3400       && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3401     {
3402       if (TREE_CODE (ifexp) == INTEGER_CST)
3403         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3404
3405       return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3406     }
3407 #endif
3408
3409   /* Promote both alternatives.  */
3410
3411   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3412     op1 = default_conversion (op1);
3413   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3414     op2 = default_conversion (op2);
3415
3416   if (TREE_CODE (ifexp) == ERROR_MARK
3417       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3418       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3419     return error_mark_node;
3420
3421   type1 = TREE_TYPE (op1);
3422   code1 = TREE_CODE (type1);
3423   type2 = TREE_TYPE (op2);
3424   code2 = TREE_CODE (type2);
3425
3426   /* Quickly detect the usual case where op1 and op2 have the same type
3427      after promotion.  */
3428   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3429     {
3430       if (type1 == type2)
3431         result_type = type1;
3432       else
3433         result_type = TYPE_MAIN_VARIANT (type1);
3434     }
3435   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3436             || code1 == COMPLEX_TYPE)
3437            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3438                || code2 == COMPLEX_TYPE))
3439     {
3440       result_type = common_type (type1, type2);
3441
3442       /* If -Wsign-compare, warn here if type1 and type2 have
3443          different signedness.  We'll promote the signed to unsigned
3444          and later code won't know it used to be different.
3445          Do this check on the original types, so that explicit casts
3446          will be considered, but default promotions won't.  */
3447       if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3448           && !skip_evaluation)
3449         {
3450           int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3451           int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3452
3453           if (unsigned_op1 ^ unsigned_op2)
3454             {
3455               /* Do not warn if the result type is signed, since the
3456                  signed type will only be chosen if it can represent
3457                  all the values of the unsigned type.  */
3458               if (! TREE_UNSIGNED (result_type))
3459                 /* OK */;
3460               /* Do not warn if the signed quantity is an unsuffixed
3461                  integer literal (or some static constant expression
3462                  involving such literals) and it is non-negative.  */
3463               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3464                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3465                 /* OK */;
3466               else
3467                 warning ("signed and unsigned type in conditional expression");
3468             }
3469         }
3470     }
3471   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3472     {
3473       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3474         pedwarn ("ISO C forbids conditional expr with only one void side");
3475       result_type = void_type_node;
3476     }
3477   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3478     {
3479       if (comp_target_types (type1, type2))
3480         result_type = common_type (type1, type2);
3481       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3482                && TREE_CODE (orig_op1) != NOP_EXPR)
3483         result_type = qualify_type (type2, type1);
3484       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3485                && TREE_CODE (orig_op2) != NOP_EXPR)
3486         result_type = qualify_type (type1, type2);
3487       else if (VOID_TYPE_P (TREE_TYPE (type1)))
3488         {
3489           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3490             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3491           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3492                                                           TREE_TYPE (type2)));
3493         }
3494       else if (VOID_TYPE_P (TREE_TYPE (type2)))
3495         {
3496           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3497             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3498           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3499                                                           TREE_TYPE (type1)));
3500         }
3501       else
3502         {
3503           pedwarn ("pointer type mismatch in conditional expression");
3504           result_type = build_pointer_type (void_type_node);
3505         }
3506     }
3507   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3508     {
3509       if (! integer_zerop (op2))
3510         pedwarn ("pointer/integer type mismatch in conditional expression");
3511       else
3512         {
3513           op2 = null_pointer_node;
3514         }
3515       result_type = type1;
3516     }
3517   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3518     {
3519       if (!integer_zerop (op1))
3520         pedwarn ("pointer/integer type mismatch in conditional expression");
3521       else
3522         {
3523           op1 = null_pointer_node;
3524         }
3525       result_type = type2;
3526     }
3527
3528   if (!result_type)
3529     {
3530       if (flag_cond_mismatch)
3531         result_type = void_type_node;
3532       else
3533         {
3534           error ("type mismatch in conditional expression");
3535           return error_mark_node;
3536         }
3537     }
3538
3539   /* Merge const and volatile flags of the incoming types.  */
3540   result_type
3541     = build_type_variant (result_type,
3542                           TREE_READONLY (op1) || TREE_READONLY (op2),
3543                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3544
3545   if (result_type != TREE_TYPE (op1))
3546     op1 = convert_and_check (result_type, op1);
3547   if (result_type != TREE_TYPE (op2))
3548     op2 = convert_and_check (result_type, op2);
3549
3550   if (TREE_CODE (ifexp) == INTEGER_CST)
3551     return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3552
3553   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3554 }
3555 \f
3556 /* Given a list of expressions, return a compound expression
3557    that performs them all and returns the value of the last of them.  */
3558
3559 tree
3560 build_compound_expr (list)
3561      tree list;
3562 {
3563   return internal_build_compound_expr (list, TRUE);
3564 }
3565
3566 static tree
3567 internal_build_compound_expr (list, first_p)
3568      tree list;
3569      int first_p;
3570 {
3571   tree rest;
3572
3573   if (TREE_CHAIN (list) == 0)
3574     {
3575       /* Convert arrays and functions to pointers when there
3576          really is a comma operator.  */
3577       if (!first_p)
3578         TREE_VALUE (list)
3579           = default_function_array_conversion (TREE_VALUE (list));
3580
3581 #if 0 /* If something inside inhibited lvalueness, we should not override.  */
3582       /* Consider (x, y+0), which is not an lvalue since y+0 is not.  */
3583
3584       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3585       if (TREE_CODE (list) == NON_LVALUE_EXPR)
3586         list = TREE_OPERAND (list, 0);
3587 #endif
3588
3589       /* Don't let (0, 0) be null pointer constant.  */
3590       if (!first_p && integer_zerop (TREE_VALUE (list)))
3591         return non_lvalue (TREE_VALUE (list));
3592       return TREE_VALUE (list);
3593     }
3594
3595   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3596
3597   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3598     {
3599       /* The left-hand operand of a comma expression is like an expression
3600          statement: with -W or -Wunused, we should warn if it doesn't have
3601          any side-effects, unless it was explicitly cast to (void).  */
3602       if ((extra_warnings || warn_unused_value)
3603            && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3604                 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3605         warning ("left-hand operand of comma expression has no effect");
3606
3607       /* When pedantic, a compound expression can be neither an lvalue
3608          nor an integer constant expression.  */
3609       if (! pedantic)
3610         return rest;
3611     }
3612
3613   /* With -Wunused, we should also warn if the left-hand operand does have
3614      side-effects, but computes a value which is not used.  For example, in
3615      `foo() + bar(), baz()' the result of the `+' operator is not used,
3616      so we should issue a warning.  */
3617   else if (warn_unused_value)
3618     warn_if_unused_value (TREE_VALUE (list));
3619
3620   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3621 }
3622
3623 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3624
3625 tree
3626 build_c_cast (type, expr)
3627      tree type;
3628      tree expr;
3629 {
3630   tree value = expr;
3631
3632   if (type == error_mark_node || expr == error_mark_node)
3633     return error_mark_node;
3634   type = TYPE_MAIN_VARIANT (type);
3635
3636 #if 0
3637   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3638   if (TREE_CODE (value) == NON_LVALUE_EXPR)
3639     value = TREE_OPERAND (value, 0);
3640 #endif
3641
3642   if (TREE_CODE (type) == ARRAY_TYPE)
3643     {
3644       error ("cast specifies array type");
3645       return error_mark_node;
3646     }
3647
3648   if (TREE_CODE (type) == FUNCTION_TYPE)
3649     {
3650       error ("cast specifies function type");
3651       return error_mark_node;
3652     }
3653
3654   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3655     {
3656       if (pedantic)
3657         {
3658           if (TREE_CODE (type) == RECORD_TYPE
3659               || TREE_CODE (type) == UNION_TYPE)
3660             pedwarn ("ISO C forbids casting nonscalar to the same type");
3661         }
3662     }
3663   else if (TREE_CODE (type) == UNION_TYPE)
3664     {
3665       tree field;
3666       value = default_function_array_conversion (value);
3667
3668       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3669         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3670                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3671           break;
3672
3673       if (field)
3674         {
3675           const char *name;
3676           tree t;
3677
3678           if (pedantic)
3679             pedwarn ("ISO C forbids casts to union type");
3680           if (TYPE_NAME (type) != 0)
3681             {
3682               if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3683                 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3684               else
3685                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3686             }
3687           else
3688             name = "";
3689           t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3690                                         build_tree_list (field, value)), 0);
3691           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3692           return t;
3693         }
3694       error ("cast to union type from type not present in union");
3695       return error_mark_node;
3696     }
3697   else
3698     {
3699       tree otype, ovalue;
3700
3701       /* If casting to void, avoid the error that would come
3702          from default_conversion in the case of a non-lvalue array.  */
3703       if (type == void_type_node)
3704         return build1 (CONVERT_EXPR, type, value);
3705
3706       /* Convert functions and arrays to pointers,
3707          but don't convert any other types.  */
3708       value = default_function_array_conversion (value);
3709       otype = TREE_TYPE (value);
3710
3711       /* Optionally warn about potentially worrisome casts.  */
3712
3713       if (warn_cast_qual
3714           && TREE_CODE (type) == POINTER_TYPE
3715           && TREE_CODE (otype) == POINTER_TYPE)
3716         {
3717           tree in_type = type;
3718           tree in_otype = otype;
3719           int added = 0;
3720           int discarded = 0;
3721
3722           /* Check that the qualifiers on IN_TYPE are a superset of
3723              the qualifiers of IN_OTYPE.  The outermost level of
3724              POINTER_TYPE nodes is uninteresting and we stop as soon
3725              as we hit a non-POINTER_TYPE node on either type.  */
3726           do
3727             {
3728               in_otype = TREE_TYPE (in_otype);
3729               in_type = TREE_TYPE (in_type);
3730
3731               /* GNU C allows cv-qualified function types.  'const'
3732                  means the function is very pure, 'volatile' means it
3733                  can't return.  We need to warn when such qualifiers
3734                  are added, not when they're taken away.  */
3735               if (TREE_CODE (in_otype) == FUNCTION_TYPE
3736                   && TREE_CODE (in_type) == FUNCTION_TYPE)
3737                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3738               else
3739                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3740             }
3741           while (TREE_CODE (in_type) == POINTER_TYPE
3742                  && TREE_CODE (in_otype) == POINTER_TYPE);
3743
3744           if (added)
3745             warning ("cast adds new qualifiers to function type");
3746
3747           if (discarded)
3748             /* There are qualifiers present in IN_OTYPE that are not
3749                present in IN_TYPE.  */
3750             warning ("cast discards qualifiers from pointer target type");
3751         }
3752
3753       /* Warn about possible alignment problems.  */
3754       if (STRICT_ALIGNMENT && warn_cast_align
3755           && TREE_CODE (type) == POINTER_TYPE
3756           && TREE_CODE (otype) == POINTER_TYPE
3757           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3758           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3759           /* Don't warn about opaque types, where the actual alignment
3760              restriction is unknown.  */
3761           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3762                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3763                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3764           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3765         warning ("cast increases required alignment of target type");
3766
3767       if (TREE_CODE (type) == INTEGER_TYPE
3768           && TREE_CODE (otype) == POINTER_TYPE
3769           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3770           && !TREE_CONSTANT (value))
3771         warning ("cast from pointer to integer of different size");
3772
3773       if (warn_bad_function_cast
3774           && TREE_CODE (value) == CALL_EXPR
3775           && TREE_CODE (type) != TREE_CODE (otype))
3776         warning ("cast does not match function type");
3777
3778       if (TREE_CODE (type) == POINTER_TYPE
3779           && TREE_CODE (otype) == INTEGER_TYPE
3780           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3781           /* Don't warn about converting any constant.  */
3782           && !TREE_CONSTANT (value))
3783         warning ("cast to pointer from integer of different size");
3784
3785       ovalue = value;
3786       value = convert (type, value);
3787
3788       /* Ignore any integer overflow caused by the cast.  */
3789       if (TREE_CODE (value) == INTEGER_CST)
3790         {
3791           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3792           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3793         }
3794     }
3795
3796   /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant.  */
3797   if (pedantic && TREE_CODE (value) == INTEGER_CST
3798       && TREE_CODE (expr) == INTEGER_CST
3799       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3800     value = non_lvalue (value);
3801
3802   /* If pedantic, don't let a cast be an lvalue.  */
3803   if (value == expr && pedantic)
3804     value = non_lvalue (value);
3805
3806   return value;
3807 }
3808
3809 /* Interpret a cast of expression EXPR to type TYPE.  */
3810 tree
3811 c_cast_expr (type, expr)
3812      tree type, expr;
3813 {
3814   int saved_wsp = warn_strict_prototypes;
3815
3816   /* This avoids warnings about unprototyped casts on
3817      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3818   if (TREE_CODE (expr) == INTEGER_CST)
3819     warn_strict_prototypes = 0;
3820   type = groktypename (type);
3821   warn_strict_prototypes = saved_wsp;
3822
3823   return build_c_cast (type, expr);
3824 }
3825
3826 \f
3827 /* Build an assignment expression of lvalue LHS from value RHS.
3828    MODIFYCODE is the code for a binary operator that we use
3829    to combine the old value of LHS with RHS to get the new value.
3830    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3831
3832 tree
3833 build_modify_expr (lhs, modifycode, rhs)
3834      tree lhs, rhs;
3835      enum tree_code modifycode;
3836 {
3837   tree result;
3838   tree newrhs;
3839   tree lhstype = TREE_TYPE (lhs);
3840   tree olhstype = lhstype;
3841
3842   /* Types that aren't fully specified cannot be used in assignments.  */
3843   lhs = require_complete_type (lhs);
3844
3845   /* Avoid duplicate error messages from operands that had errors.  */
3846   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3847     return error_mark_node;
3848
3849   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3850   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3851      whose value is 0 to count as a null pointer constant.  */
3852   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3853     rhs = TREE_OPERAND (rhs, 0);
3854
3855   newrhs = rhs;
3856
3857   /* Handle control structure constructs used as "lvalues".  */
3858
3859   switch (TREE_CODE (lhs))
3860     {
3861       /* Handle (a, b) used as an "lvalue".  */
3862     case COMPOUND_EXPR:
3863       pedantic_lvalue_warning (COMPOUND_EXPR);
3864       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3865       if (TREE_CODE (newrhs) == ERROR_MARK)
3866         return error_mark_node;
3867       return build (COMPOUND_EXPR, lhstype,
3868                     TREE_OPERAND (lhs, 0), newrhs);
3869
3870       /* Handle (a ? b : c) used as an "lvalue".  */
3871     case COND_EXPR:
3872       pedantic_lvalue_warning (COND_EXPR);
3873       rhs = save_expr (rhs);
3874       {
3875         /* Produce (a ? (b = rhs) : (c = rhs))
3876            except that the RHS goes through a save-expr
3877            so the code to compute it is only emitted once.  */
3878         tree cond
3879           = build_conditional_expr (TREE_OPERAND (lhs, 0),
3880                                     build_modify_expr (TREE_OPERAND (lhs, 1),
3881                                                        modifycode, rhs),
3882                                     build_modify_expr (TREE_OPERAND (lhs, 2),
3883                                                        modifycode, rhs));
3884         if (TREE_CODE (cond) == ERROR_MARK)
3885           return cond;
3886         /* Make sure the code to compute the rhs comes out
3887            before the split.  */
3888         return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3889                       /* But cast it to void to avoid an "unused" error.  */
3890                       convert (void_type_node, rhs), cond);
3891       }
3892     default:
3893       break;
3894     }
3895
3896   /* If a binary op has been requested, combine the old LHS value with the RHS
3897      producing the value we should actually store into the LHS.  */
3898
3899   if (modifycode != NOP_EXPR)
3900     {
3901       lhs = stabilize_reference (lhs);
3902       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3903     }
3904
3905   /* Handle a cast used as an "lvalue".
3906      We have already performed any binary operator using the value as cast.
3907      Now convert the result to the cast type of the lhs,
3908      and then true type of the lhs and store it there;
3909      then convert result back to the cast type to be the value
3910      of the assignment.  */
3911
3912   switch (TREE_CODE (lhs))
3913     {
3914     case NOP_EXPR:
3915     case CONVERT_EXPR:
3916     case FLOAT_EXPR:
3917     case FIX_TRUNC_EXPR:
3918     case FIX_FLOOR_EXPR:
3919     case FIX_ROUND_EXPR:
3920     case FIX_CEIL_EXPR:
3921       newrhs = default_function_array_conversion (newrhs);
3922       {
3923         tree inner_lhs = TREE_OPERAND (lhs, 0);
3924         tree result;
3925         result = build_modify_expr (inner_lhs, NOP_EXPR,
3926                                     convert (TREE_TYPE (inner_lhs),
3927                                              convert (lhstype, newrhs)));
3928         if (TREE_CODE (result) == ERROR_MARK)
3929           return result;
3930         pedantic_lvalue_warning (CONVERT_EXPR);
3931         return convert (TREE_TYPE (lhs), result);
3932       }
3933
3934     default:
3935       break;
3936     }
3937
3938   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3939      Reject anything strange now.  */
3940
3941   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3942     return error_mark_node;
3943
3944   /* Warn about storing in something that is `const'.  */
3945
3946   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3947       || ((TREE_CODE (lhstype) == RECORD_TYPE
3948            || TREE_CODE (lhstype) == UNION_TYPE)
3949           && C_TYPE_FIELDS_READONLY (lhstype)))
3950     readonly_warning (lhs, "assignment");
3951
3952   /* If storing into a structure or union member,
3953      it has probably been given type `int'.
3954      Compute the type that would go with
3955      the actual amount of storage the member occupies.  */
3956
3957   if (TREE_CODE (lhs) == COMPONENT_REF
3958       && (TREE_CODE (lhstype) == INTEGER_TYPE
3959           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3960           || TREE_CODE (lhstype) == REAL_TYPE
3961           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3962     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3963
3964   /* If storing in a field that is in actuality a short or narrower than one,
3965      we must store in the field in its actual type.  */
3966
3967   if (lhstype != TREE_TYPE (lhs))
3968     {
3969       lhs = copy_node (lhs);
3970       TREE_TYPE (lhs) = lhstype;
3971     }
3972
3973   /* Convert new value to destination type.  */
3974
3975   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3976                                    NULL_TREE, NULL_TREE, 0);
3977   if (TREE_CODE (newrhs) == ERROR_MARK)
3978     return error_mark_node;
3979
3980   /* Scan operands */
3981
3982   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3983   TREE_SIDE_EFFECTS (result) = 1;
3984
3985   /* If we got the LHS in a different type for storing in,
3986      convert the result back to the nominal type of LHS
3987      so that the value we return always has the same type
3988      as the LHS argument.  */
3989
3990   if (olhstype == TREE_TYPE (result))
3991     return result;
3992   return convert_for_assignment (olhstype, result, _("assignment"),
3993                                  NULL_TREE, NULL_TREE, 0);
3994 }
3995 \f
3996 /* Convert value RHS to type TYPE as preparation for an assignment
3997    to an lvalue of type TYPE.
3998    The real work of conversion is done by `convert'.
3999    The purpose of this function is to generate error messages
4000    for assignments that are not allowed in C.
4001    ERRTYPE is a string to use in error messages:
4002    "assignment", "return", etc.  If it is null, this is parameter passing
4003    for a function call (and different error messages are output).
4004
4005    FUNNAME is the name of the function being called,
4006    as an IDENTIFIER_NODE, or null.
4007    PARMNUM is the number of the argument, for printing in error messages.  */
4008
4009 static tree
4010 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4011      tree type, rhs;
4012      const char *errtype;
4013      tree fundecl, funname;
4014      int parmnum;
4015 {
4016   enum tree_code codel = TREE_CODE (type);
4017   tree rhstype;
4018   enum tree_code coder;
4019
4020   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4021   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4022      whose value is 0 to count as a null pointer constant.  */
4023   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4024     rhs = TREE_OPERAND (rhs, 0);
4025
4026   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4027       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4028     rhs = default_conversion (rhs);
4029   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4030     rhs = decl_constant_value_for_broken_optimization (rhs);
4031
4032   rhstype = TREE_TYPE (rhs);
4033   coder = TREE_CODE (rhstype);
4034
4035   if (coder == ERROR_MARK)
4036     return error_mark_node;
4037
4038   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4039     {
4040       overflow_warning (rhs);
4041       /* Check for Objective-C protocols.  This will issue a warning if
4042          there are protocol violations.  No need to use the return value.  */
4043       maybe_objc_comptypes (type, rhstype, 0);
4044       return rhs;
4045     }
4046
4047   if (coder == VOID_TYPE)
4048     {
4049       error ("void value not ignored as it ought to be");
4050       return error_mark_node;
4051     }
4052   /* A type converts to a reference to it.
4053      This code doesn't fully support references, it's just for the
4054      special case of va_start and va_copy.  */
4055   if (codel == REFERENCE_TYPE
4056       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4057     {
4058       if (!lvalue_p (rhs))
4059         {
4060           error ("cannot pass rvalue to reference parameter");
4061           return error_mark_node;
4062         }
4063       if (!c_mark_addressable (rhs))
4064         return error_mark_node;
4065       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4066
4067       /* We already know that these two types are compatible, but they
4068          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
4069          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4070          likely to be va_list, a typedef to __builtin_va_list, which
4071          is different enough that it will cause problems later.  */
4072       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4073         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4074
4075       rhs = build1 (NOP_EXPR, type, rhs);
4076       return rhs;
4077     }
4078   /* Arithmetic types all interconvert, and enum is treated like int.  */
4079   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4080             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4081             || codel == BOOLEAN_TYPE)
4082            && (coder == INTEGER_TYPE || coder == REAL_TYPE
4083                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4084                || coder == BOOLEAN_TYPE))
4085     return convert_and_check (type, rhs);
4086
4087   /* Conversion to a transparent union from its member types.
4088      This applies only to function arguments.  */
4089   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4090     {
4091       tree memb_types;
4092       tree marginal_memb_type = 0;
4093
4094       for (memb_types = TYPE_FIELDS (type); memb_types;
4095            memb_types = TREE_CHAIN (memb_types))
4096         {
4097           tree memb_type = TREE_TYPE (memb_types);
4098
4099           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4100                          TYPE_MAIN_VARIANT (rhstype)))
4101             break;
4102
4103           if (TREE_CODE (memb_type) != POINTER_TYPE)
4104             continue;
4105
4106           if (coder == POINTER_TYPE)
4107             {
4108               tree ttl = TREE_TYPE (memb_type);
4109               tree ttr = TREE_TYPE (rhstype);
4110
4111               /* Any non-function converts to a [const][volatile] void *
4112                  and vice versa; otherwise, targets must be the same.
4113                  Meanwhile, the lhs target must have all the qualifiers of
4114                  the rhs.  */
4115               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4116                   || comp_target_types (memb_type, rhstype))
4117                 {
4118                   /* If this type won't generate any warnings, use it.  */
4119                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4120                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
4121                            && TREE_CODE (ttl) == FUNCTION_TYPE)
4122                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4123                              == TYPE_QUALS (ttr))
4124                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4125                              == TYPE_QUALS (ttl))))
4126                     break;
4127
4128                   /* Keep looking for a better type, but remember this one.  */
4129                   if (! marginal_memb_type)
4130                     marginal_memb_type = memb_type;
4131                 }
4132             }
4133
4134           /* Can convert integer zero to any pointer type.  */
4135           if (integer_zerop (rhs)
4136               || (TREE_CODE (rhs) == NOP_EXPR
4137                   && integer_zerop (TREE_OPERAND (rhs, 0))))
4138             {
4139               rhs = null_pointer_node;
4140               break;
4141             }
4142         }
4143
4144       if (memb_types || marginal_memb_type)
4145         {
4146           if (! memb_types)
4147             {
4148               /* We have only a marginally acceptable member type;
4149                  it needs a warning.  */
4150               tree ttl = TREE_TYPE (marginal_memb_type);
4151               tree ttr = TREE_TYPE (rhstype);
4152
4153               /* Const and volatile mean something different for function
4154                  types, so the usual warnings are not appropriate.  */
4155               if (TREE_CODE (ttr) == FUNCTION_TYPE
4156                   && TREE_CODE (ttl) == FUNCTION_TYPE)
4157                 {
4158                   /* Because const and volatile on functions are
4159                      restrictions that say the function will not do
4160                      certain things, it is okay to use a const or volatile
4161                      function where an ordinary one is wanted, but not
4162                      vice-versa.  */
4163                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4164                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
4165                                          errtype, funname, parmnum);
4166                 }
4167               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4168                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4169                                      errtype, funname,
4170                                      parmnum);
4171             }
4172
4173           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4174             pedwarn ("ISO C prohibits argument conversion to union type");
4175
4176           return build1 (NOP_EXPR, type, rhs);
4177         }
4178     }
4179
4180   /* Conversions among pointers */
4181   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4182            && (coder == codel))
4183     {
4184       tree ttl = TREE_TYPE (type);
4185       tree ttr = TREE_TYPE (rhstype);
4186
4187       /* Any non-function converts to a [const][volatile] void *
4188          and vice versa; otherwise, targets must be the same.
4189          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4190       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4191           || comp_target_types (type, rhstype)
4192           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
4193               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4194         {
4195           if (pedantic
4196               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4197                   ||
4198                   (VOID_TYPE_P (ttr)
4199                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
4200                       which are not ANSI null ptr constants.  */
4201                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4202                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4203             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4204                                  errtype, funname, parmnum);
4205           /* Const and volatile mean something different for function types,
4206              so the usual warnings are not appropriate.  */
4207           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4208                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4209             {
4210               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4211                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4212                                      errtype, funname, parmnum);
4213               /* If this is not a case of ignoring a mismatch in signedness,
4214                  no warning.  */
4215               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4216                        || comp_target_types (type, rhstype))
4217                 ;
4218               /* If there is a mismatch, do warn.  */
4219               else if (pedantic)
4220                 warn_for_assignment ("pointer targets in %s differ in signedness",
4221                                      errtype, funname, parmnum);
4222             }
4223           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4224                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4225             {
4226               /* Because const and volatile on functions are restrictions
4227                  that say the function will not do certain things,
4228                  it is okay to use a const or volatile function
4229                  where an ordinary one is wanted, but not vice-versa.  */
4230               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4231                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4232                                      errtype, funname, parmnum);
4233             }
4234         }
4235       else
4236         warn_for_assignment ("%s from incompatible pointer type",
4237                              errtype, funname, parmnum);
4238       return convert (type, rhs);
4239     }
4240   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4241     {
4242       /* An explicit constant 0 can convert to a pointer,
4243          or one that results from arithmetic, even including
4244          a cast to integer type.  */
4245       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4246           &&
4247           ! (TREE_CODE (rhs) == NOP_EXPR
4248              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4249              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4250              && integer_zerop (TREE_OPERAND (rhs, 0))))
4251         {
4252           warn_for_assignment ("%s makes pointer from integer without a cast",
4253                                errtype, funname, parmnum);
4254           return convert (type, rhs);
4255         }
4256       return null_pointer_node;
4257     }
4258   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4259     {
4260       warn_for_assignment ("%s makes integer from pointer without a cast",
4261                            errtype, funname, parmnum);
4262       return convert (type, rhs);
4263     }
4264   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4265     return convert (type, rhs);
4266
4267   if (!errtype)
4268     {
4269       if (funname)
4270         {
4271           tree selector = maybe_building_objc_message_expr ();
4272
4273           if (selector && parmnum > 2)
4274             error ("incompatible type for argument %d of `%s'",
4275                    parmnum - 2, IDENTIFIER_POINTER (selector));
4276           else
4277             error ("incompatible type for argument %d of `%s'",
4278                    parmnum, IDENTIFIER_POINTER (funname));
4279         }
4280       else
4281         error ("incompatible type for argument %d of indirect function call",
4282                parmnum);
4283     }
4284   else
4285     error ("incompatible types in %s", errtype);
4286
4287   return error_mark_node;
4288 }
4289
4290 /* Convert VALUE for assignment into inlined parameter PARM.  */
4291
4292 tree
4293 c_convert_parm_for_inlining (parm, value, fn)
4294      tree parm, value, fn;
4295 {
4296   tree ret, type;
4297
4298   /* If FN was prototyped, the value has been converted already
4299      in convert_arguments.  */
4300   if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
4301     return value;
4302
4303   type = TREE_TYPE (parm);
4304   ret = convert_for_assignment (type, value,
4305                                 (char *) 0 /* arg passing  */, fn,
4306                                 DECL_NAME (fn), 0);
4307   if (PROMOTE_PROTOTYPES
4308       && INTEGRAL_TYPE_P (type)
4309       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
4310     ret = default_conversion (ret);
4311   return ret;
4312 }
4313
4314 /* Print a warning using MSGID.
4315    It gets OPNAME as its one parameter.
4316    If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4317    FUNCTION and ARGNUM are handled specially if we are building an
4318    Objective-C selector.  */
4319
4320 static void
4321 warn_for_assignment (msgid, opname, function, argnum)
4322      const char *msgid;
4323      const char *opname;
4324      tree function;
4325      int argnum;
4326 {
4327   if (opname == 0)
4328     {
4329       tree selector = maybe_building_objc_message_expr ();
4330       char * new_opname;
4331
4332       if (selector && argnum > 2)
4333         {
4334           function = selector;
4335           argnum -= 2;
4336         }
4337       if (function)
4338         {
4339           /* Function name is known; supply it.  */
4340           const char *const argstring = _("passing arg %d of `%s'");
4341           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4342                                         + strlen (argstring) + 1 + 25
4343                                         /*%d*/ + 1);
4344           sprintf (new_opname, argstring, argnum,
4345                    IDENTIFIER_POINTER (function));
4346         }
4347       else
4348         {
4349           /* Function name unknown (call through ptr); just give arg number.  */
4350           const char *const argnofun = _("passing arg %d of pointer to function");
4351           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4352           sprintf (new_opname, argnofun, argnum);
4353         }
4354       opname = new_opname;
4355     }
4356   pedwarn (msgid, opname);
4357 }
4358 \f
4359 /* If VALUE is a compound expr all of whose expressions are constant, then
4360    return its value.  Otherwise, return error_mark_node.
4361
4362    This is for handling COMPOUND_EXPRs as initializer elements
4363    which is allowed with a warning when -pedantic is specified.  */
4364
4365 static tree
4366 valid_compound_expr_initializer (value, endtype)
4367      tree value;
4368      tree endtype;
4369 {
4370   if (TREE_CODE (value) == COMPOUND_EXPR)
4371     {
4372       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4373           == error_mark_node)
4374         return error_mark_node;
4375       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4376                                               endtype);
4377     }
4378   else if (! TREE_CONSTANT (value)
4379            && ! initializer_constant_valid_p (value, endtype))
4380     return error_mark_node;
4381   else
4382     return value;
4383 }
4384 \f
4385 /* Perform appropriate conversions on the initial value of a variable,
4386    store it in the declaration DECL,
4387    and print any error messages that are appropriate.
4388    If the init is invalid, store an ERROR_MARK.  */
4389
4390 void
4391 store_init_value (decl, init)
4392      tree decl, init;
4393 {
4394   tree value, type;
4395
4396   /* If variable's type was invalidly declared, just ignore it.  */
4397
4398   type = TREE_TYPE (decl);
4399   if (TREE_CODE (type) == ERROR_MARK)
4400     return;
4401
4402   /* Digest the specified initializer into an expression.  */
4403
4404   value = digest_init (type, init, TREE_STATIC (decl));
4405
4406   /* Store the expression if valid; else report error.  */
4407
4408 #if 0
4409   /* Note that this is the only place we can detect the error
4410      in a case such as   struct foo bar = (struct foo) { x, y };
4411      where there is one initial value which is a constructor expression.  */
4412   if (value == error_mark_node)
4413     ;
4414   else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4415     {
4416       error ("initializer for static variable is not constant");
4417       value = error_mark_node;
4418     }
4419   else if (TREE_STATIC (decl)
4420            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4421     {
4422       error ("initializer for static variable uses complicated arithmetic");
4423       value = error_mark_node;
4424     }
4425   else
4426     {
4427       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4428         {
4429           if (! TREE_CONSTANT (value))
4430             pedwarn ("aggregate initializer is not constant");
4431           else if (! TREE_STATIC (value))
4432             pedwarn ("aggregate initializer uses complicated arithmetic");
4433         }
4434     }
4435 #endif
4436
4437   if (warn_traditional && !in_system_header
4438       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4439     warning ("traditional C rejects automatic aggregate initialization");
4440
4441   DECL_INITIAL (decl) = value;
4442
4443   /* ANSI wants warnings about out-of-range constant initializers.  */
4444   STRIP_TYPE_NOPS (value);
4445   constant_expression_warning (value);
4446
4447   /* Check if we need to set array size from compound literal size.  */
4448   if (TREE_CODE (type) == ARRAY_TYPE
4449       && TYPE_DOMAIN (type) == 0
4450       && value != error_mark_node)
4451     {
4452       tree inside_init = init;
4453
4454       if (TREE_CODE (init) == NON_LVALUE_EXPR)
4455         inside_init = TREE_OPERAND (init, 0);
4456       inside_init = fold (inside_init);
4457
4458       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4459         {
4460           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4461
4462           if (TYPE_DOMAIN (TREE_TYPE (decl)))
4463             {
4464               /* For int foo[] = (int [3]){1}; we need to set array size
4465                  now since later on array initializer will be just the
4466                  brace enclosed list of the compound literal.  */
4467               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
4468               layout_type (type);
4469               layout_decl (decl, 0);
4470             }
4471         }
4472     }
4473 }
4474 \f
4475 /* Methods for storing and printing names for error messages.  */
4476
4477 /* Implement a spelling stack that allows components of a name to be pushed
4478    and popped.  Each element on the stack is this structure.  */
4479
4480 struct spelling
4481 {
4482   int kind;
4483   union
4484     {
4485       int i;
4486       const char *s;
4487     } u;
4488 };
4489
4490 #define SPELLING_STRING 1
4491 #define SPELLING_MEMBER 2
4492 #define SPELLING_BOUNDS 3
4493
4494 static struct spelling *spelling;       /* Next stack element (unused).  */
4495 static struct spelling *spelling_base;  /* Spelling stack base.  */
4496 static int spelling_size;               /* Size of the spelling stack.  */
4497
4498 /* Macros to save and restore the spelling stack around push_... functions.
4499    Alternative to SAVE_SPELLING_STACK.  */
4500
4501 #define SPELLING_DEPTH() (spelling - spelling_base)
4502 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4503
4504 /* Save and restore the spelling stack around arbitrary C code.  */
4505
4506 #define SAVE_SPELLING_DEPTH(code)               \
4507 {                                               \
4508   int __depth = SPELLING_DEPTH ();              \
4509   code;                                         \
4510   RESTORE_SPELLING_DEPTH (__depth);             \
4511 }
4512
4513 /* Push an element on the spelling stack with type KIND and assign VALUE
4514    to MEMBER.  */
4515
4516 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4517 {                                                                       \
4518   int depth = SPELLING_DEPTH ();                                        \
4519                                                                         \
4520   if (depth >= spelling_size)                                           \
4521     {                                                                   \
4522       spelling_size += 10;                                              \
4523       if (spelling_base == 0)                                           \
4524         spelling_base                                                   \
4525           = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));     \
4526       else                                                              \
4527         spelling_base                                                   \
4528           = (struct spelling *) xrealloc (spelling_base,                \
4529                                           spelling_size * sizeof (struct spelling));    \
4530       RESTORE_SPELLING_DEPTH (depth);                                   \
4531     }                                                                   \
4532                                                                         \
4533   spelling->kind = (KIND);                                              \
4534   spelling->MEMBER = (VALUE);                                           \
4535   spelling++;                                                           \
4536 }
4537
4538 /* Push STRING on the stack.  Printed literally.  */
4539
4540 static void
4541 push_string (string)
4542      const char *string;
4543 {
4544   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4545 }
4546
4547 /* Push a member name on the stack.  Printed as '.' STRING.  */
4548
4549 static void
4550 push_member_name (decl)
4551      tree decl;
4552
4553 {
4554   const char *const string
4555     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4556   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4557 }
4558
4559 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4560
4561 static void
4562 push_array_bounds (bounds)
4563      int bounds;
4564 {
4565   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4566 }
4567
4568 /* Compute the maximum size in bytes of the printed spelling.  */
4569
4570 static int
4571 spelling_length ()
4572 {
4573   int size = 0;
4574   struct spelling *p;
4575
4576   for (p = spelling_base; p < spelling; p++)
4577     {
4578       if (p->kind == SPELLING_BOUNDS)
4579         size += 25;
4580       else
4581         size += strlen (p->u.s) + 1;
4582     }
4583
4584   return size;
4585 }
4586
4587 /* Print the spelling to BUFFER and return it.  */
4588
4589 static char *
4590 print_spelling (buffer)
4591      char *buffer;
4592 {
4593   char *d = buffer;
4594   struct spelling *p;
4595
4596   for (p = spelling_base; p < spelling; p++)
4597     if (p->kind == SPELLING_BOUNDS)
4598       {
4599         sprintf (d, "[%d]", p->u.i);
4600         d += strlen (d);
4601       }
4602     else
4603       {
4604         const char *s;
4605         if (p->kind == SPELLING_MEMBER)
4606           *d++ = '.';
4607         for (s = p->u.s; (*d = *s++); d++)
4608           ;
4609       }
4610   *d++ = '\0';
4611   return buffer;
4612 }
4613
4614 /* Issue an error message for a bad initializer component.
4615    MSGID identifies the message.
4616    The component name is taken from the spelling stack.  */
4617
4618 void
4619 error_init (msgid)
4620      const char *msgid;
4621 {
4622   char *ofwhat;
4623
4624   error ("%s", _(msgid));
4625   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4626   if (*ofwhat)
4627     error ("(near initialization for `%s')", ofwhat);
4628 }
4629
4630 /* Issue a pedantic warning for a bad initializer component.
4631    MSGID identifies the message.
4632    The component name is taken from the spelling stack.  */
4633
4634 void
4635 pedwarn_init (msgid)
4636      const char *msgid;
4637 {
4638   char *ofwhat;
4639
4640   pedwarn ("%s", _(msgid));
4641   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4642   if (*ofwhat)
4643     pedwarn ("(near initialization for `%s')", ofwhat);
4644 }
4645
4646 /* Issue a warning for a bad initializer component.
4647    MSGID identifies the message.
4648    The component name is taken from the spelling stack.  */
4649
4650 static void
4651 warning_init (msgid)
4652      const char *msgid;
4653 {
4654   char *ofwhat;
4655
4656   warning ("%s", _(msgid));
4657   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4658   if (*ofwhat)
4659     warning ("(near initialization for `%s')", ofwhat);
4660 }
4661 \f
4662 /* Digest the parser output INIT as an initializer for type TYPE.
4663    Return a C expression of type TYPE to represent the initial value.
4664
4665    REQUIRE_CONSTANT requests an error if non-constant initializers or
4666    elements are seen.  */
4667
4668 static tree
4669 digest_init (type, init, require_constant)
4670      tree type, init;
4671      int require_constant;
4672 {
4673   enum tree_code code = TREE_CODE (type);
4674   tree inside_init = init;
4675
4676   if (type == error_mark_node
4677       || init == error_mark_node
4678       || TREE_TYPE (init) == error_mark_node)
4679     return error_mark_node;
4680
4681   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4682   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4683      whose value is 0 to count as a null pointer constant.  */
4684   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4685     inside_init = TREE_OPERAND (init, 0);
4686
4687   inside_init = fold (inside_init);
4688
4689   /* Initialization of an array of chars from a string constant
4690      optionally enclosed in braces.  */
4691
4692   if (code == ARRAY_TYPE)
4693     {
4694       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4695       if ((typ1 == char_type_node
4696            || typ1 == signed_char_type_node
4697            || typ1 == unsigned_char_type_node
4698            || typ1 == unsigned_wchar_type_node
4699            || typ1 == signed_wchar_type_node)
4700           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4701         {
4702           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4703                          TYPE_MAIN_VARIANT (type)))
4704             return inside_init;
4705
4706           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4707                != char_type_node)
4708               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4709             {
4710               error_init ("char-array initialized from wide string");
4711               return error_mark_node;
4712             }
4713           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4714                == char_type_node)
4715               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4716             {
4717               error_init ("int-array initialized from non-wide string");
4718               return error_mark_node;
4719             }
4720
4721           TREE_TYPE (inside_init) = type;
4722           if (TYPE_DOMAIN (type) != 0
4723               && TYPE_SIZE (type) != 0
4724               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4725               /* Subtract 1 (or sizeof (wchar_t))
4726                  because it's ok to ignore the terminating null char
4727                  that is counted in the length of the constant.  */
4728               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4729                                        TREE_STRING_LENGTH (inside_init)
4730                                        - ((TYPE_PRECISION (typ1)
4731                                            != TYPE_PRECISION (char_type_node))
4732                                           ? (TYPE_PRECISION (wchar_type_node)
4733                                              / BITS_PER_UNIT)
4734                                           : 1)))
4735             pedwarn_init ("initializer-string for array of chars is too long");
4736
4737           return inside_init;
4738         }
4739     }
4740
4741   /* Any type can be initialized
4742      from an expression of the same type, optionally with braces.  */
4743
4744   if (inside_init && TREE_TYPE (inside_init) != 0
4745       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4746                      TYPE_MAIN_VARIANT (type))
4747           || (code == ARRAY_TYPE
4748               && comptypes (TREE_TYPE (inside_init), type))
4749           || (code == VECTOR_TYPE
4750               && comptypes (TREE_TYPE (inside_init), type))
4751           || (code == POINTER_TYPE
4752               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4753                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4754               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4755                             TREE_TYPE (type)))))
4756     {
4757       if (code == POINTER_TYPE)
4758         inside_init = default_function_array_conversion (inside_init);
4759
4760       if (require_constant && !flag_isoc99
4761           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4762         {
4763           /* As an extension, allow initializing objects with static storage
4764              duration with compound literals (which are then treated just as
4765              the brace enclosed list they contain).  */
4766           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4767           inside_init = DECL_INITIAL (decl);
4768         }
4769
4770       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4771           && TREE_CODE (inside_init) != CONSTRUCTOR)
4772         {
4773           error_init ("array initialized from non-constant array expression");
4774           return error_mark_node;
4775         }
4776
4777       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4778         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4779
4780       /* Compound expressions can only occur here if -pedantic or
4781          -pedantic-errors is specified.  In the later case, we always want
4782          an error.  In the former case, we simply want a warning.  */
4783       if (require_constant && pedantic
4784           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4785         {
4786           inside_init
4787             = valid_compound_expr_initializer (inside_init,
4788                                                TREE_TYPE (inside_init));
4789           if (inside_init == error_mark_node)
4790             error_init ("initializer element is not constant");
4791           else
4792             pedwarn_init ("initializer element is not constant");
4793           if (flag_pedantic_errors)
4794             inside_init = error_mark_node;
4795         }
4796       else if (require_constant
4797                && (!TREE_CONSTANT (inside_init)
4798                    /* This test catches things like `7 / 0' which
4799                       result in an expression for which TREE_CONSTANT
4800                       is true, but which is not actually something
4801                       that is a legal constant.  We really should not
4802                       be using this function, because it is a part of
4803                       the back-end.  Instead, the expression should
4804                       already have been turned into ERROR_MARK_NODE.  */
4805                    || !initializer_constant_valid_p (inside_init,
4806                                                      TREE_TYPE (inside_init))))
4807         {
4808           error_init ("initializer element is not constant");
4809           inside_init = error_mark_node;
4810         }
4811
4812       return inside_init;
4813     }
4814
4815   /* Handle scalar types, including conversions.  */
4816
4817   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4818       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4819     {
4820       /* Note that convert_for_assignment calls default_conversion
4821          for arrays and functions.  We must not call it in the
4822          case where inside_init is a null pointer constant.  */
4823       inside_init
4824         = convert_for_assignment (type, init, _("initialization"),
4825                                   NULL_TREE, NULL_TREE, 0);
4826
4827       if (require_constant && ! TREE_CONSTANT (inside_init))
4828         {
4829           error_init ("initializer element is not constant");
4830           inside_init = error_mark_node;
4831         }
4832       else if (require_constant
4833                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4834         {
4835           error_init ("initializer element is not computable at load time");
4836           inside_init = error_mark_node;
4837         }
4838
4839       return inside_init;
4840     }
4841
4842   /* Come here only for records and arrays.  */
4843
4844   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4845     {
4846       error_init ("variable-sized object may not be initialized");
4847       return error_mark_node;
4848     }
4849
4850   error_init ("invalid initializer");
4851   return error_mark_node;
4852 }
4853 \f
4854 /* Handle initializers that use braces.  */
4855
4856 /* Type of object we are accumulating a constructor for.
4857    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4858 static tree constructor_type;
4859
4860 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4861    left to fill.  */
4862 static tree constructor_fields;
4863
4864 /* For an ARRAY_TYPE, this is the specified index
4865    at which to store the next element we get.  */
4866 static tree constructor_index;
4867
4868 /* For an ARRAY_TYPE, this is the maximum index.  */
4869 static tree constructor_max_index;
4870
4871 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4872 static tree constructor_unfilled_fields;
4873
4874 /* For an ARRAY_TYPE, this is the index of the first element
4875    not yet written out.  */
4876 static tree constructor_unfilled_index;
4877
4878 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4879    This is so we can generate gaps between fields, when appropriate.  */
4880 static tree constructor_bit_index;
4881
4882 /* If we are saving up the elements rather than allocating them,
4883    this is the list of elements so far (in reverse order,
4884    most recent first).  */
4885 static tree constructor_elements;
4886
4887 /* 1 if constructor should be incrementally stored into a constructor chain,
4888    0 if all the elements should be kept in AVL tree.  */
4889 static int constructor_incremental;
4890
4891 /* 1 if so far this constructor's elements are all compile-time constants.  */
4892 static int constructor_constant;
4893
4894 /* 1 if so far this constructor's elements are all valid address constants.  */
4895 static int constructor_simple;
4896
4897 /* 1 if this constructor is erroneous so far.  */
4898 static int constructor_erroneous;
4899
4900 /* 1 if have called defer_addressed_constants.  */
4901 static int constructor_subconstants_deferred;
4902
4903 /* Structure for managing pending initializer elements, organized as an
4904    AVL tree.  */
4905
4906 struct init_node
4907 {
4908   struct init_node *left, *right;
4909   struct init_node *parent;
4910   int balance;
4911   tree purpose;
4912   tree value;
4913 };
4914
4915 /* Tree of pending elements at this constructor level.
4916    These are elements encountered out of order
4917    which belong at places we haven't reached yet in actually
4918    writing the output.
4919    Will never hold tree nodes across GC runs.  */
4920 static struct init_node *constructor_pending_elts;
4921
4922 /* The SPELLING_DEPTH of this constructor.  */
4923 static int constructor_depth;
4924
4925 /* 0 if implicitly pushing constructor levels is allowed.  */
4926 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4927
4928 static int require_constant_value;
4929 static int require_constant_elements;
4930
4931 /* DECL node for which an initializer is being read.
4932    0 means we are reading a constructor expression
4933    such as (struct foo) {...}.  */
4934 static tree constructor_decl;
4935
4936 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4937 static const char *constructor_asmspec;
4938
4939 /* Nonzero if this is an initializer for a top-level decl.  */
4940 static int constructor_top_level;
4941
4942 /* Nonzero if there were any member designators in this initializer.  */
4943 static int constructor_designated;
4944
4945 /* Nesting depth of designator list.  */
4946 static int designator_depth;
4947
4948 /* Nonzero if there were diagnosed errors in this designator list.  */
4949 static int designator_errorneous;
4950
4951 \f
4952 /* This stack has a level for each implicit or explicit level of
4953    structuring in the initializer, including the outermost one.  It
4954    saves the values of most of the variables above.  */
4955
4956 struct constructor_range_stack;
4957
4958 struct constructor_stack
4959 {
4960   struct constructor_stack *next;
4961   tree type;
4962   tree fields;
4963   tree index;
4964   tree max_index;
4965   tree unfilled_index;
4966   tree unfilled_fields;
4967   tree bit_index;
4968   tree elements;
4969   struct init_node *pending_elts;
4970   int offset;
4971   int depth;
4972   /* If nonzero, this value should replace the entire
4973      constructor at this level.  */
4974   tree replacement_value;
4975   struct constructor_range_stack *range_stack;
4976   char constant;
4977   char simple;
4978   char implicit;
4979   char erroneous;
4980   char outer;
4981   char incremental;
4982   char designated;
4983 };
4984
4985 struct constructor_stack *constructor_stack;
4986
4987 /* This stack represents designators from some range designator up to
4988    the last designator in the list.  */
4989
4990 struct constructor_range_stack
4991 {
4992   struct constructor_range_stack *next, *prev;
4993   struct constructor_stack *stack;
4994   tree range_start;
4995   tree index;
4996   tree range_end;
4997   tree fields;
4998 };
4999
5000 struct constructor_range_stack *constructor_range_stack;
5001
5002 /* This stack records separate initializers that are nested.
5003    Nested initializers can't happen in ANSI C, but GNU C allows them
5004    in cases like { ... (struct foo) { ... } ... }.  */
5005
5006 struct initializer_stack
5007 {
5008   struct initializer_stack *next;
5009   tree decl;
5010   const char *asmspec;
5011   struct constructor_stack *constructor_stack;
5012   struct constructor_range_stack *constructor_range_stack;
5013   tree elements;
5014   struct spelling *spelling;
5015   struct spelling *spelling_base;
5016   int spelling_size;
5017   char top_level;
5018   char require_constant_value;
5019   char require_constant_elements;
5020   char deferred;
5021 };
5022
5023 struct initializer_stack *initializer_stack;
5024 \f
5025 /* Prepare to parse and output the initializer for variable DECL.  */
5026
5027 void
5028 start_init (decl, asmspec_tree, top_level)
5029      tree decl;
5030      tree asmspec_tree;
5031      int top_level;
5032 {
5033   const char *locus;
5034   struct initializer_stack *p
5035     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5036   const char *asmspec = 0;
5037
5038   if (asmspec_tree)
5039     asmspec = TREE_STRING_POINTER (asmspec_tree);
5040
5041   p->decl = constructor_decl;
5042   p->asmspec = constructor_asmspec;
5043   p->require_constant_value = require_constant_value;
5044   p->require_constant_elements = require_constant_elements;
5045   p->constructor_stack = constructor_stack;
5046   p->constructor_range_stack = constructor_range_stack;
5047   p->elements = constructor_elements;
5048   p->spelling = spelling;
5049   p->spelling_base = spelling_base;
5050   p->spelling_size = spelling_size;
5051   p->deferred = constructor_subconstants_deferred;
5052   p->top_level = constructor_top_level;
5053   p->next = initializer_stack;
5054   initializer_stack = p;
5055
5056   constructor_decl = decl;
5057   constructor_asmspec = asmspec;
5058   constructor_subconstants_deferred = 0;
5059   constructor_designated = 0;
5060   constructor_top_level = top_level;
5061
5062   if (decl != 0)
5063     {
5064       require_constant_value = TREE_STATIC (decl);
5065       require_constant_elements
5066         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5067            /* For a scalar, you can always use any value to initialize,
5068               even within braces.  */
5069            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5070                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5071                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5072                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5073       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5074     }
5075   else
5076     {
5077       require_constant_value = 0;
5078       require_constant_elements = 0;
5079       locus = "(anonymous)";
5080     }
5081
5082   constructor_stack = 0;
5083   constructor_range_stack = 0;
5084
5085   missing_braces_mentioned = 0;
5086
5087   spelling_base = 0;
5088   spelling_size = 0;
5089   RESTORE_SPELLING_DEPTH (0);
5090
5091   if (locus)
5092     push_string (locus);
5093 }
5094
5095 void
5096 finish_init ()
5097 {
5098   struct initializer_stack *p = initializer_stack;
5099
5100   /* Output subconstants (string constants, usually)
5101      that were referenced within this initializer and saved up.
5102      Must do this if and only if we called defer_addressed_constants.  */
5103   if (constructor_subconstants_deferred)
5104     output_deferred_addressed_constants ();
5105
5106   /* Free the whole constructor stack of this initializer.  */
5107   while (constructor_stack)
5108     {
5109       struct constructor_stack *q = constructor_stack;
5110       constructor_stack = q->next;
5111       free (q);
5112     }
5113
5114   if (constructor_range_stack)
5115     abort ();
5116
5117   /* Pop back to the data of the outer initializer (if any).  */
5118   constructor_decl = p->decl;
5119   constructor_asmspec = p->asmspec;
5120   require_constant_value = p->require_constant_value;
5121   require_constant_elements = p->require_constant_elements;
5122   constructor_stack = p->constructor_stack;
5123   constructor_range_stack = p->constructor_range_stack;
5124   constructor_elements = p->elements;
5125   spelling = p->spelling;
5126   spelling_base = p->spelling_base;
5127   spelling_size = p->spelling_size;
5128   constructor_subconstants_deferred = p->deferred;
5129   constructor_top_level = p->top_level;
5130   initializer_stack = p->next;
5131   free (p);
5132 }
5133 \f
5134 /* Call here when we see the initializer is surrounded by braces.
5135    This is instead of a call to push_init_level;
5136    it is matched by a call to pop_init_level.
5137
5138    TYPE is the type to initialize, for a constructor expression.
5139    For an initializer for a decl, TYPE is zero.  */
5140
5141 void
5142 really_start_incremental_init (type)
5143      tree type;
5144 {
5145   struct constructor_stack *p
5146     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5147
5148   if (type == 0)
5149     type = TREE_TYPE (constructor_decl);
5150
5151   p->type = constructor_type;
5152   p->fields = constructor_fields;
5153   p->index = constructor_index;
5154   p->max_index = constructor_max_index;
5155   p->unfilled_index = constructor_unfilled_index;
5156   p->unfilled_fields = constructor_unfilled_fields;
5157   p->bit_index = constructor_bit_index;
5158   p->elements = constructor_elements;
5159   p->constant = constructor_constant;
5160   p->simple = constructor_simple;
5161   p->erroneous = constructor_erroneous;
5162   p->pending_elts = constructor_pending_elts;
5163   p->depth = constructor_depth;
5164   p->replacement_value = 0;
5165   p->implicit = 0;
5166   p->range_stack = 0;
5167   p->outer = 0;
5168   p->incremental = constructor_incremental;
5169   p->designated = constructor_designated;
5170   p->next = 0;
5171   constructor_stack = p;
5172
5173   constructor_constant = 1;
5174   constructor_simple = 1;
5175   constructor_depth = SPELLING_DEPTH ();
5176   constructor_elements = 0;
5177   constructor_pending_elts = 0;
5178   constructor_type = type;
5179   constructor_incremental = 1;
5180   constructor_designated = 0;
5181   designator_depth = 0;
5182   designator_errorneous = 0;
5183
5184   if (TREE_CODE (constructor_type) == RECORD_TYPE
5185       || TREE_CODE (constructor_type) == UNION_TYPE)
5186     {
5187       constructor_fields = TYPE_FIELDS (constructor_type);
5188       /* Skip any nameless bit fields at the beginning.  */
5189       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5190              && DECL_NAME (constructor_fields) == 0)
5191         constructor_fields = TREE_CHAIN (constructor_fields);
5192
5193       constructor_unfilled_fields = constructor_fields;
5194       constructor_bit_index = bitsize_zero_node;
5195     }
5196   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5197     {
5198       if (TYPE_DOMAIN (constructor_type))
5199         {
5200           constructor_max_index
5201             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5202
5203           /* Detect non-empty initializations of zero-length arrays.  */
5204           if (constructor_max_index == NULL_TREE
5205               && TYPE_SIZE (constructor_type))
5206             constructor_max_index = build_int_2 (-1, -1);
5207
5208           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
5209              to initialize VLAs will cause an proper error; avoid tree
5210              checking errors as well by setting a safe value.  */
5211           if (constructor_max_index
5212               && TREE_CODE (constructor_max_index) != INTEGER_CST)
5213             constructor_max_index = build_int_2 (-1, -1);
5214
5215           constructor_index
5216             = convert (bitsizetype,
5217                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5218         }
5219       else
5220         constructor_index = bitsize_zero_node;
5221
5222       constructor_unfilled_index = constructor_index;
5223     }
5224   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5225     {
5226       /* Vectors are like simple fixed-size arrays.  */
5227       constructor_max_index =
5228         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
5229       constructor_index = convert (bitsizetype, bitsize_zero_node);
5230       constructor_unfilled_index = constructor_index;
5231     }
5232   else
5233     {
5234       /* Handle the case of int x = {5}; */
5235       constructor_fields = constructor_type;
5236       constructor_unfilled_fields = constructor_type;
5237     }
5238 }
5239 \f
5240 /* Push down into a subobject, for initialization.
5241    If this is for an explicit set of braces, IMPLICIT is 0.
5242    If it is because the next element belongs at a lower level,
5243    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
5244
5245 void
5246 push_init_level (implicit)
5247      int implicit;
5248 {
5249   struct constructor_stack *p;
5250   tree value = NULL_TREE;
5251
5252   /* If we've exhausted any levels that didn't have braces,
5253      pop them now.  */
5254   while (constructor_stack->implicit)
5255     {
5256       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5257            || TREE_CODE (constructor_type) == UNION_TYPE)
5258           && constructor_fields == 0)
5259         process_init_element (pop_init_level (1));
5260       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5261                && tree_int_cst_lt (constructor_max_index, constructor_index))
5262         process_init_element (pop_init_level (1));
5263       else
5264         break;
5265     }
5266
5267   /* Unless this is an explicit brace, we need to preserve previous
5268      content if any.  */
5269   if (implicit)
5270     {
5271       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5272            || TREE_CODE (constructor_type) == UNION_TYPE)
5273           && constructor_fields)
5274         value = find_init_member (constructor_fields);
5275       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5276         value = find_init_member (constructor_index);
5277     }
5278
5279   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5280   p->type = constructor_type;
5281   p->fields = constructor_fields;
5282   p->index = constructor_index;
5283   p->max_index = constructor_max_index;
5284   p->unfilled_index = constructor_unfilled_index;
5285   p->unfilled_fields = constructor_unfilled_fields;
5286   p->bit_index = constructor_bit_index;
5287   p->elements = constructor_elements;
5288   p->constant = constructor_constant;
5289   p->simple = constructor_simple;
5290   p->erroneous = constructor_erroneous;
5291   p->pending_elts = constructor_pending_elts;
5292   p->depth = constructor_depth;
5293   p->replacement_value = 0;
5294   p->implicit = implicit;
5295   p->outer = 0;
5296   p->incremental = constructor_incremental;
5297   p->designated = constructor_designated;
5298   p->next = constructor_stack;
5299   p->range_stack = 0;
5300   constructor_stack = p;
5301
5302   constructor_constant = 1;
5303   constructor_simple = 1;
5304   constructor_depth = SPELLING_DEPTH ();
5305   constructor_elements = 0;
5306   constructor_incremental = 1;
5307   constructor_designated = 0;
5308   constructor_pending_elts = 0;
5309   if (!implicit)
5310     {
5311       p->range_stack = constructor_range_stack;
5312       constructor_range_stack = 0;
5313       designator_depth = 0;
5314       designator_errorneous = 0;
5315     }
5316
5317   /* Don't die if an entire brace-pair level is superfluous
5318      in the containing level.  */
5319   if (constructor_type == 0)
5320     ;
5321   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5322            || TREE_CODE (constructor_type) == UNION_TYPE)
5323     {
5324       /* Don't die if there are extra init elts at the end.  */
5325       if (constructor_fields == 0)
5326         constructor_type = 0;
5327       else
5328         {
5329           constructor_type = TREE_TYPE (constructor_fields);
5330           push_member_name (constructor_fields);
5331           constructor_depth++;
5332         }
5333     }
5334   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5335     {
5336       constructor_type = TREE_TYPE (constructor_type);
5337       push_array_bounds (tree_low_cst (constructor_index, 0));
5338       constructor_depth++;
5339     }
5340
5341   if (constructor_type == 0)
5342     {
5343       error_init ("extra brace group at end of initializer");
5344       constructor_fields = 0;
5345       constructor_unfilled_fields = 0;
5346       return;
5347     }
5348
5349   if (value && TREE_CODE (value) == CONSTRUCTOR)
5350     {
5351       constructor_constant = TREE_CONSTANT (value);
5352       constructor_simple = TREE_STATIC (value);
5353       constructor_elements = TREE_OPERAND (value, 1);
5354       if (constructor_elements
5355           && (TREE_CODE (constructor_type) == RECORD_TYPE
5356               || TREE_CODE (constructor_type) == ARRAY_TYPE))
5357         set_nonincremental_init ();
5358     }
5359
5360   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5361     {
5362       missing_braces_mentioned = 1;
5363       warning_init ("missing braces around initializer");
5364     }
5365
5366   if (TREE_CODE (constructor_type) == RECORD_TYPE
5367            || TREE_CODE (constructor_type) == UNION_TYPE)
5368     {
5369       constructor_fields = TYPE_FIELDS (constructor_type);
5370       /* Skip any nameless bit fields at the beginning.  */
5371       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5372              && DECL_NAME (constructor_fields) == 0)
5373         constructor_fields = TREE_CHAIN (constructor_fields);
5374
5375       constructor_unfilled_fields = constructor_fields;
5376       constructor_bit_index = bitsize_zero_node;
5377     }
5378   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5379     {
5380       /* Vectors are like simple fixed-size arrays.  */
5381       constructor_max_index =
5382         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
5383       constructor_index = convert (bitsizetype, integer_zero_node);
5384       constructor_unfilled_index = constructor_index;
5385     }
5386   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5387     {
5388       if (TYPE_DOMAIN (constructor_type))
5389         {
5390           constructor_max_index
5391             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5392
5393           /* Detect non-empty initializations of zero-length arrays.  */
5394           if (constructor_max_index == NULL_TREE
5395               && TYPE_SIZE (constructor_type))
5396             constructor_max_index = build_int_2 (-1, -1);
5397
5398           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
5399              to initialize VLAs will cause an proper error; avoid tree
5400              checking errors as well by setting a safe value.  */
5401           if (constructor_max_index
5402               && TREE_CODE (constructor_max_index) != INTEGER_CST)
5403             constructor_max_index = build_int_2 (-1, -1);
5404
5405           constructor_index
5406             = convert (bitsizetype,
5407                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5408         }
5409       else
5410         constructor_index = bitsize_zero_node;
5411
5412       constructor_unfilled_index = constructor_index;
5413       if (value && TREE_CODE (value) == STRING_CST)
5414         {
5415           /* We need to split the char/wchar array into individual
5416              characters, so that we don't have to special case it
5417              everywhere.  */
5418           set_nonincremental_init_from_string (value);
5419         }
5420     }
5421   else
5422     {
5423       warning_init ("braces around scalar initializer");
5424       constructor_fields = constructor_type;
5425       constructor_unfilled_fields = constructor_type;
5426     }
5427 }
5428
5429 /* At the end of an implicit or explicit brace level,
5430    finish up that level of constructor.
5431    If we were outputting the elements as they are read, return 0
5432    from inner levels (process_init_element ignores that),
5433    but return error_mark_node from the outermost level
5434    (that's what we want to put in DECL_INITIAL).
5435    Otherwise, return a CONSTRUCTOR expression.  */
5436
5437 tree
5438 pop_init_level (implicit)
5439      int implicit;
5440 {
5441   struct constructor_stack *p;
5442   tree constructor = 0;
5443
5444   if (implicit == 0)
5445     {
5446       /* When we come to an explicit close brace,
5447          pop any inner levels that didn't have explicit braces.  */
5448       while (constructor_stack->implicit)
5449         process_init_element (pop_init_level (1));
5450
5451       if (constructor_range_stack)
5452         abort ();
5453     }
5454
5455   p = constructor_stack;
5456
5457   /* Error for initializing a flexible array member, or a zero-length
5458      array member in an inappropriate context.  */
5459   if (constructor_type && constructor_fields
5460       && TREE_CODE (constructor_type) == ARRAY_TYPE
5461       && TYPE_DOMAIN (constructor_type)
5462       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5463     {
5464       /* Silently discard empty initializations.  The parser will
5465          already have pedwarned for empty brackets.  */
5466       if (integer_zerop (constructor_unfilled_index))
5467         constructor_type = NULL_TREE;
5468       else if (! TYPE_SIZE (constructor_type))
5469         {
5470           if (constructor_depth > 2)
5471             error_init ("initialization of flexible array member in a nested context");
5472           else if (pedantic)
5473             pedwarn_init ("initialization of a flexible array member");
5474
5475           /* We have already issued an error message for the existence
5476              of a flexible array member not at the end of the structure.
5477              Discard the initializer so that we do not abort later.  */
5478           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5479             constructor_type = NULL_TREE;
5480         }
5481       else
5482         /* Zero-length arrays are no longer special, so we should no longer
5483            get here.  */
5484         abort ();
5485     }
5486
5487   /* Warn when some struct elements are implicitly initialized to zero.  */
5488   if (extra_warnings
5489       && constructor_type
5490       && TREE_CODE (constructor_type) == RECORD_TYPE
5491       && constructor_unfilled_fields)
5492     {
5493         /* Do not warn for flexible array members or zero-length arrays.  */
5494         while (constructor_unfilled_fields
5495                && (! DECL_SIZE (constructor_unfilled_fields)
5496                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5497           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5498
5499         /* Do not warn if this level of the initializer uses member
5500            designators; it is likely to be deliberate.  */
5501         if (constructor_unfilled_fields && !constructor_designated)
5502           {
5503             push_member_name (constructor_unfilled_fields);
5504             warning_init ("missing initializer");
5505             RESTORE_SPELLING_DEPTH (constructor_depth);
5506           }
5507     }
5508
5509   /* Now output all pending elements.  */
5510   constructor_incremental = 1;
5511   output_pending_init_elements (1);
5512
5513   /* Pad out the end of the structure.  */
5514   if (p->replacement_value)
5515     /* If this closes a superfluous brace pair,
5516        just pass out the element between them.  */
5517     constructor = p->replacement_value;
5518   else if (constructor_type == 0)
5519     ;
5520   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5521            && TREE_CODE (constructor_type) != UNION_TYPE
5522            && TREE_CODE (constructor_type) != ARRAY_TYPE
5523            && TREE_CODE (constructor_type) != VECTOR_TYPE)
5524     {
5525       /* A nonincremental scalar initializer--just return
5526          the element, after verifying there is just one.  */
5527       if (constructor_elements == 0)
5528         {
5529           if (!constructor_erroneous)
5530             error_init ("empty scalar initializer");
5531           constructor = error_mark_node;
5532         }
5533       else if (TREE_CHAIN (constructor_elements) != 0)
5534         {
5535           error_init ("extra elements in scalar initializer");
5536           constructor = TREE_VALUE (constructor_elements);
5537         }
5538       else
5539         constructor = TREE_VALUE (constructor_elements);
5540     }
5541   else
5542     {
5543       if (constructor_erroneous)
5544         constructor = error_mark_node;
5545       else
5546         {
5547           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5548                                nreverse (constructor_elements));
5549           if (constructor_constant)
5550             TREE_CONSTANT (constructor) = 1;
5551           if (constructor_constant && constructor_simple)
5552             TREE_STATIC (constructor) = 1;
5553         }
5554     }
5555
5556   constructor_type = p->type;
5557   constructor_fields = p->fields;
5558   constructor_index = p->index;
5559   constructor_max_index = p->max_index;
5560   constructor_unfilled_index = p->unfilled_index;
5561   constructor_unfilled_fields = p->unfilled_fields;
5562   constructor_bit_index = p->bit_index;
5563   constructor_elements = p->elements;
5564   constructor_constant = p->constant;
5565   constructor_simple = p->simple;
5566   constructor_erroneous = p->erroneous;
5567   constructor_incremental = p->incremental;
5568   constructor_designated = p->designated;
5569   constructor_pending_elts = p->pending_elts;
5570   constructor_depth = p->depth;
5571   if (!p->implicit)
5572     constructor_range_stack = p->range_stack;
5573   RESTORE_SPELLING_DEPTH (constructor_depth);
5574
5575   constructor_stack = p->next;
5576   free (p);
5577
5578   if (constructor == 0)
5579     {
5580       if (constructor_stack == 0)
5581         return error_mark_node;
5582       return NULL_TREE;
5583     }
5584   return constructor;
5585 }
5586
5587 /* Common handling for both array range and field name designators.
5588    ARRAY argument is non-zero for array ranges.  Returns zero for success.  */
5589
5590 static int
5591 set_designator (array)
5592      int array;
5593 {
5594   tree subtype;
5595   enum tree_code subcode;
5596
5597   /* Don't die if an entire brace-pair level is superfluous
5598      in the containing level.  */
5599   if (constructor_type == 0)
5600     return 1;
5601
5602   /* If there were errors in this designator list already, bail out silently.  */
5603   if (designator_errorneous)
5604     return 1;
5605
5606   if (!designator_depth)
5607     {
5608       if (constructor_range_stack)
5609         abort ();
5610
5611       /* Designator list starts at the level of closest explicit
5612          braces.  */
5613       while (constructor_stack->implicit)
5614         process_init_element (pop_init_level (1));
5615       constructor_designated = 1;
5616       return 0;
5617     }
5618
5619   if (constructor_no_implicit)
5620     {
5621       error_init ("initialization designators may not nest");
5622       return 1;
5623     }
5624
5625   if (TREE_CODE (constructor_type) == RECORD_TYPE
5626       || TREE_CODE (constructor_type) == UNION_TYPE)
5627     {
5628       subtype = TREE_TYPE (constructor_fields);
5629       if (subtype != error_mark_node)
5630         subtype = TYPE_MAIN_VARIANT (subtype);
5631     }
5632   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5633     {
5634       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5635     }
5636   else
5637     abort ();
5638
5639   subcode = TREE_CODE (subtype);
5640   if (array && subcode != ARRAY_TYPE)
5641     {
5642       error_init ("array index in non-array initializer");
5643       return 1;
5644     }
5645   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5646     {
5647       error_init ("field name not in record or union initializer");
5648       return 1;
5649     }
5650
5651   constructor_designated = 1;
5652   push_init_level (2);
5653   return 0;
5654 }
5655
5656 /* If there are range designators in designator list, push a new designator
5657    to constructor_range_stack.  RANGE_END is end of such stack range or
5658    NULL_TREE if there is no range designator at this level.  */
5659
5660 static void
5661 push_range_stack (range_end)
5662      tree range_end;
5663 {
5664   struct constructor_range_stack *p;
5665
5666   p = (struct constructor_range_stack *)
5667       ggc_alloc (sizeof (struct constructor_range_stack));
5668   p->prev = constructor_range_stack;
5669   p->next = 0;
5670   p->fields = constructor_fields;
5671   p->range_start = constructor_index;
5672   p->index = constructor_index;
5673   p->stack = constructor_stack;
5674   p->range_end = range_end;
5675   if (constructor_range_stack)
5676     constructor_range_stack->next = p;
5677   constructor_range_stack = p;
5678 }
5679
5680 /* Within an array initializer, specify the next index to be initialized.
5681    FIRST is that index.  If LAST is nonzero, then initialize a range
5682    of indices, running from FIRST through LAST.  */
5683
5684 void
5685 set_init_index (first, last)
5686      tree first, last;
5687 {
5688   if (set_designator (1))
5689     return;
5690
5691   designator_errorneous = 1;
5692
5693   while ((TREE_CODE (first) == NOP_EXPR
5694           || TREE_CODE (first) == CONVERT_EXPR
5695           || TREE_CODE (first) == NON_LVALUE_EXPR)
5696          && (TYPE_MODE (TREE_TYPE (first))
5697              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5698     first = TREE_OPERAND (first, 0);
5699
5700   if (last)
5701     while ((TREE_CODE (last) == NOP_EXPR
5702             || TREE_CODE (last) == CONVERT_EXPR
5703             || TREE_CODE (last) == NON_LVALUE_EXPR)
5704            && (TYPE_MODE (TREE_TYPE (last))
5705                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5706       last = TREE_OPERAND (last, 0);
5707
5708   if (TREE_CODE (first) != INTEGER_CST)
5709     error_init ("nonconstant array index in initializer");
5710   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5711     error_init ("nonconstant array index in initializer");
5712   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5713     error_init ("array index in non-array initializer");
5714   else if (constructor_max_index
5715            && tree_int_cst_lt (constructor_max_index, first))
5716     error_init ("array index in initializer exceeds array bounds");
5717   else
5718     {
5719       constructor_index = convert (bitsizetype, first);
5720
5721       if (last)
5722         {
5723           if (tree_int_cst_equal (first, last))
5724             last = 0;
5725           else if (tree_int_cst_lt (last, first))
5726             {
5727               error_init ("empty index range in initializer");
5728               last = 0;
5729             }
5730           else
5731             {
5732               last = convert (bitsizetype, last);
5733               if (constructor_max_index != 0
5734                   && tree_int_cst_lt (constructor_max_index, last))
5735                 {
5736                   error_init ("array index range in initializer exceeds array bounds");
5737                   last = 0;
5738                 }
5739             }
5740         }
5741
5742       designator_depth++;
5743       designator_errorneous = 0;
5744       if (constructor_range_stack || last)
5745         push_range_stack (last);
5746     }
5747 }
5748
5749 /* Within a struct initializer, specify the next field to be initialized.  */
5750
5751 void
5752 set_init_label (fieldname)
5753      tree fieldname;
5754 {
5755   tree tail;
5756
5757   if (set_designator (0))
5758     return;
5759
5760   designator_errorneous = 1;
5761
5762   if (TREE_CODE (constructor_type) != RECORD_TYPE
5763       && TREE_CODE (constructor_type) != UNION_TYPE)
5764     {
5765       error_init ("field name not in record or union initializer");
5766       return;
5767     }
5768
5769   for (tail = TYPE_FIELDS (constructor_type); tail;
5770        tail = TREE_CHAIN (tail))
5771     {
5772       if (DECL_NAME (tail) == fieldname)
5773         break;
5774     }
5775
5776   if (tail == 0)
5777     error ("unknown field `%s' specified in initializer",
5778            IDENTIFIER_POINTER (fieldname));
5779   else
5780     {
5781       constructor_fields = tail;
5782       designator_depth++;
5783       designator_errorneous = 0;
5784       if (constructor_range_stack)
5785         push_range_stack (NULL_TREE);
5786     }
5787 }
5788 \f
5789 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5790    identifies the initializer, either array index or field in a structure.
5791    VALUE is the value of that index or field.  */
5792
5793 static void
5794 add_pending_init (purpose, value)
5795      tree purpose, value;
5796 {
5797   struct init_node *p, **q, *r;
5798
5799   q = &constructor_pending_elts;
5800   p = 0;
5801
5802   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5803     {
5804       while (*q != 0)
5805         {
5806           p = *q;
5807           if (tree_int_cst_lt (purpose, p->purpose))
5808             q = &p->left;
5809           else if (tree_int_cst_lt (p->purpose, purpose))
5810             q = &p->right;
5811           else
5812             {
5813               if (TREE_SIDE_EFFECTS (p->value))
5814                 warning_init ("initialized field with side-effects overwritten");
5815               p->value = value;
5816               return;
5817             }
5818         }
5819     }
5820   else
5821     {
5822       tree bitpos;
5823
5824       bitpos = bit_position (purpose);
5825       while (*q != NULL)
5826         {
5827           p = *q;
5828           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5829             q = &p->left;
5830           else if (p->purpose != purpose)
5831             q = &p->right;
5832           else
5833             {
5834               if (TREE_SIDE_EFFECTS (p->value))
5835                 warning_init ("initialized field with side-effects overwritten");
5836               p->value = value;
5837               return;
5838             }
5839         }
5840     }
5841
5842   r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5843   r->purpose = purpose;
5844   r->value = value;
5845
5846   *q = r;
5847   r->parent = p;
5848   r->left = 0;
5849   r->right = 0;
5850   r->balance = 0;
5851
5852   while (p)
5853     {
5854       struct init_node *s;
5855
5856       if (r == p->left)
5857         {
5858           if (p->balance == 0)
5859             p->balance = -1;
5860           else if (p->balance < 0)
5861             {
5862               if (r->balance < 0)
5863                 {
5864                   /* L rotation.  */
5865                   p->left = r->right;
5866                   if (p->left)
5867                     p->left->parent = p;
5868                   r->right = p;
5869
5870                   p->balance = 0;
5871                   r->balance = 0;
5872
5873                   s = p->parent;
5874                   p->parent = r;
5875                   r->parent = s;
5876                   if (s)
5877                     {
5878                       if (s->left == p)
5879                         s->left = r;
5880                       else
5881                         s->right = r;
5882                     }
5883                   else
5884                     constructor_pending_elts = r;
5885                 }
5886               else
5887                 {
5888                   /* LR rotation.  */
5889                   struct init_node *t = r->right;
5890
5891                   r->right = t->left;
5892                   if (r->right)
5893                     r->right->parent = r;
5894                   t->left = r;
5895
5896                   p->left = t->right;
5897                   if (p->left)
5898                     p->left->parent = p;
5899                   t->right = p;
5900
5901                   p->balance = t->balance < 0;
5902                   r->balance = -(t->balance > 0);
5903                   t->balance = 0;
5904
5905                   s = p->parent;
5906                   p->parent = t;
5907                   r->parent = t;
5908                   t->parent = s;
5909                   if (s)
5910                     {
5911                       if (s->left == p)
5912                         s->left = t;
5913                       else
5914                         s->right = t;
5915                     }
5916                   else
5917                     constructor_pending_elts = t;
5918                 }
5919               break;
5920             }
5921           else
5922             {
5923               /* p->balance == +1; growth of left side balances the node.  */
5924               p->balance = 0;
5925               break;
5926             }
5927         }
5928       else /* r == p->right */
5929         {
5930           if (p->balance == 0)
5931             /* Growth propagation from right side.  */
5932             p->balance++;
5933           else if (p->balance > 0)
5934             {
5935               if (r->balance > 0)
5936                 {
5937                   /* R rotation.  */
5938                   p->right = r->left;
5939                   if (p->right)
5940                     p->right->parent = p;
5941                   r->left = p;
5942
5943                   p->balance = 0;
5944                   r->balance = 0;
5945
5946                   s = p->parent;
5947                   p->parent = r;
5948                   r->parent = s;
5949                   if (s)
5950                     {
5951                       if (s->left == p)
5952                         s->left = r;
5953                       else
5954                         s->right = r;
5955                     }
5956                   else
5957                     constructor_pending_elts = r;
5958                 }
5959               else /* r->balance == -1 */
5960                 {
5961                   /* RL rotation */
5962                   struct init_node *t = r->left;
5963
5964                   r->left = t->right;
5965                   if (r->left)
5966                     r->left->parent = r;
5967                   t->right = r;
5968
5969                   p->right = t->left;
5970                   if (p->right)
5971                     p->right->parent = p;
5972                   t->left = p;
5973
5974                   r->balance = (t->balance < 0);
5975                   p->balance = -(t->balance > 0);
5976                   t->balance = 0;
5977
5978                   s = p->parent;
5979                   p->parent = t;
5980                   r->parent = t;
5981                   t->parent = s;
5982                   if (s)
5983                     {
5984                       if (s->left == p)
5985                         s->left = t;
5986                       else
5987                         s->right = t;
5988                     }
5989                   else
5990                     constructor_pending_elts = t;
5991                 }
5992               break;
5993             }
5994           else
5995             {
5996               /* p->balance == -1; growth of right side balances the node.  */
5997               p->balance = 0;
5998               break;
5999             }
6000         }
6001
6002       r = p;
6003       p = p->parent;
6004     }
6005 }
6006
6007 /* Build AVL tree from a sorted chain.  */
6008
6009 static void
6010 set_nonincremental_init ()
6011 {
6012   tree chain;
6013
6014   if (TREE_CODE (constructor_type) != RECORD_TYPE
6015       && TREE_CODE (constructor_type) != ARRAY_TYPE)
6016     return;
6017
6018   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
6019     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
6020   constructor_elements = 0;
6021   if (TREE_CODE (constructor_type) == RECORD_TYPE)
6022     {
6023       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
6024       /* Skip any nameless bit fields at the beginning.  */
6025       while (constructor_unfilled_fields != 0
6026              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6027              && DECL_NAME (constructor_unfilled_fields) == 0)
6028         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6029
6030     }
6031   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6032     {
6033       if (TYPE_DOMAIN (constructor_type))
6034         constructor_unfilled_index
6035             = convert (bitsizetype,
6036                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6037       else
6038         constructor_unfilled_index = bitsize_zero_node;
6039     }
6040   constructor_incremental = 0;
6041 }
6042
6043 /* Build AVL tree from a string constant.  */
6044
6045 static void
6046 set_nonincremental_init_from_string (str)
6047      tree str;
6048 {
6049   tree value, purpose, type;
6050   HOST_WIDE_INT val[2];
6051   const char *p, *end;
6052   int byte, wchar_bytes, charwidth, bitpos;
6053
6054   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6055     abort ();
6056
6057   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6058       == TYPE_PRECISION (char_type_node))
6059     wchar_bytes = 1;
6060   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6061            == TYPE_PRECISION (wchar_type_node))
6062     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6063   else
6064     abort ();
6065
6066   charwidth = TYPE_PRECISION (char_type_node);
6067   type = TREE_TYPE (constructor_type);
6068   p = TREE_STRING_POINTER (str);
6069   end = p + TREE_STRING_LENGTH (str);
6070
6071   for (purpose = bitsize_zero_node;
6072        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6073        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6074     {
6075       if (wchar_bytes == 1)
6076         {
6077           val[1] = (unsigned char) *p++;
6078           val[0] = 0;
6079         }
6080       else
6081         {
6082           val[0] = 0;
6083           val[1] = 0;
6084           for (byte = 0; byte < wchar_bytes; byte++)
6085             {
6086               if (BYTES_BIG_ENDIAN)
6087                 bitpos = (wchar_bytes - byte - 1) * charwidth;
6088               else
6089                 bitpos = byte * charwidth;
6090               val[bitpos < HOST_BITS_PER_WIDE_INT]
6091                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6092                    << (bitpos % HOST_BITS_PER_WIDE_INT);
6093             }
6094         }
6095
6096       if (!TREE_UNSIGNED (type))
6097         {
6098           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6099           if (bitpos < HOST_BITS_PER_WIDE_INT)
6100             {
6101               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6102                 {
6103                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6104                   val[0] = -1;
6105                 }
6106             }
6107           else if (bitpos == HOST_BITS_PER_WIDE_INT)
6108             {
6109               if (val[1] < 0)
6110                 val[0] = -1;
6111             }
6112           else if (val[0] & (((HOST_WIDE_INT) 1)
6113                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6114             val[0] |= ((HOST_WIDE_INT) -1)
6115                       << (bitpos - HOST_BITS_PER_WIDE_INT);
6116         }
6117
6118       value = build_int_2 (val[1], val[0]);
6119       TREE_TYPE (value) = type;
6120       add_pending_init (purpose, value);
6121     }
6122
6123   constructor_incremental = 0;
6124 }
6125
6126 /* Return value of FIELD in pending initializer or zero if the field was
6127    not initialized yet.  */
6128
6129 static tree
6130 find_init_member (field)
6131      tree field;
6132 {
6133   struct init_node *p;
6134
6135   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6136     {
6137       if (constructor_incremental
6138           && tree_int_cst_lt (field, constructor_unfilled_index))
6139         set_nonincremental_init ();
6140
6141       p = constructor_pending_elts;
6142       while (p)
6143         {
6144           if (tree_int_cst_lt (field, p->purpose))
6145             p = p->left;
6146           else if (tree_int_cst_lt (p->purpose, field))
6147             p = p->right;
6148           else
6149             return p->value;
6150         }
6151     }
6152   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6153     {
6154       tree bitpos = bit_position (field);
6155
6156       if (constructor_incremental
6157           && (!constructor_unfilled_fields
6158               || tree_int_cst_lt (bitpos,
6159                                   bit_position (constructor_unfilled_fields))))
6160         set_nonincremental_init ();
6161
6162       p = constructor_pending_elts;
6163       while (p)
6164         {
6165           if (field == p->purpose)
6166             return p->value;
6167           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6168             p = p->left;
6169           else
6170             p = p->right;
6171         }
6172     }
6173   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6174     {
6175       if (constructor_elements
6176           && TREE_PURPOSE (constructor_elements) == field)
6177         return TREE_VALUE (constructor_elements);
6178     }
6179   return 0;
6180 }
6181
6182 /* "Output" the next constructor element.
6183    At top level, really output it to assembler code now.
6184    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6185    TYPE is the data type that the containing data type wants here.
6186    FIELD is the field (a FIELD_DECL) or the index that this element fills.
6187
6188    PENDING if non-nil means output pending elements that belong
6189    right after this element.  (PENDING is normally 1;
6190    it is 0 while outputting pending elements, to avoid recursion.)  */
6191
6192 static void
6193 output_init_element (value, type, field, pending)
6194      tree value, type, field;
6195      int pending;
6196 {
6197   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6198       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6199           && !(TREE_CODE (value) == STRING_CST
6200                && TREE_CODE (type) == ARRAY_TYPE
6201                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6202           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6203                          TYPE_MAIN_VARIANT (type))))
6204     value = default_conversion (value);
6205
6206   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
6207       && require_constant_value && !flag_isoc99 && pending)
6208     {
6209       /* As an extension, allow initializing objects with static storage
6210          duration with compound literals (which are then treated just as
6211          the brace enclosed list they contain).  */
6212       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
6213       value = DECL_INITIAL (decl);
6214     }
6215
6216   if (value == error_mark_node)
6217     constructor_erroneous = 1;
6218   else if (!TREE_CONSTANT (value))
6219     constructor_constant = 0;
6220   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6221            || ((TREE_CODE (constructor_type) == RECORD_TYPE
6222                 || TREE_CODE (constructor_type) == UNION_TYPE)
6223                && DECL_C_BIT_FIELD (field)
6224                && TREE_CODE (value) != INTEGER_CST))
6225     constructor_simple = 0;
6226
6227   if (require_constant_value && ! TREE_CONSTANT (value))
6228     {
6229       error_init ("initializer element is not constant");
6230       value = error_mark_node;
6231     }
6232   else if (require_constant_elements
6233            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6234     pedwarn ("initializer element is not computable at load time");
6235
6236   /* If this field is empty (and not at the end of structure),
6237      don't do anything other than checking the initializer.  */
6238   if (field
6239       && (TREE_TYPE (field) == error_mark_node
6240           || (COMPLETE_TYPE_P (TREE_TYPE (field))
6241               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6242               && (TREE_CODE (constructor_type) == ARRAY_TYPE
6243                   || TREE_CHAIN (field)))))
6244     return;
6245
6246   value = digest_init (type, value, require_constant_value);
6247   if (value == error_mark_node)
6248     {
6249       constructor_erroneous = 1;
6250       return;
6251     }
6252
6253   /* If this element doesn't come next in sequence,
6254      put it on constructor_pending_elts.  */
6255   if (TREE_CODE (constructor_type) == ARRAY_TYPE
6256       && (!constructor_incremental
6257           || !tree_int_cst_equal (field, constructor_unfilled_index)))
6258     {
6259       if (constructor_incremental
6260           && tree_int_cst_lt (field, constructor_unfilled_index))
6261         set_nonincremental_init ();
6262
6263       add_pending_init (field, value);
6264       return;
6265     }
6266   else if (TREE_CODE (constructor_type) == RECORD_TYPE
6267            && (!constructor_incremental
6268                || field != constructor_unfilled_fields))
6269     {
6270       /* We do this for records but not for unions.  In a union,
6271          no matter which field is specified, it can be initialized
6272          right away since it starts at the beginning of the union.  */
6273       if (constructor_incremental)
6274         {
6275           if (!constructor_unfilled_fields)
6276             set_nonincremental_init ();
6277           else
6278             {
6279               tree bitpos, unfillpos;
6280
6281               bitpos = bit_position (field);
6282               unfillpos = bit_position (constructor_unfilled_fields);
6283
6284               if (tree_int_cst_lt (bitpos, unfillpos))
6285                 set_nonincremental_init ();
6286             }
6287         }
6288
6289       add_pending_init (field, value);
6290       return;
6291     }
6292   else if (TREE_CODE (constructor_type) == UNION_TYPE
6293            && constructor_elements)
6294     {
6295       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6296         warning_init ("initialized field with side-effects overwritten");
6297
6298       /* We can have just one union field set.  */
6299       constructor_elements = 0;
6300     }
6301
6302   /* Otherwise, output this element either to
6303      constructor_elements or to the assembler file.  */
6304
6305   if (field && TREE_CODE (field) == INTEGER_CST)
6306     field = copy_node (field);
6307   constructor_elements
6308     = tree_cons (field, value, constructor_elements);
6309
6310   /* Advance the variable that indicates sequential elements output.  */
6311   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6312     constructor_unfilled_index
6313       = size_binop (PLUS_EXPR, constructor_unfilled_index,
6314                     bitsize_one_node);
6315   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6316     {
6317       constructor_unfilled_fields
6318         = TREE_CHAIN (constructor_unfilled_fields);
6319
6320       /* Skip any nameless bit fields.  */
6321       while (constructor_unfilled_fields != 0
6322              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6323              && DECL_NAME (constructor_unfilled_fields) == 0)
6324         constructor_unfilled_fields =
6325           TREE_CHAIN (constructor_unfilled_fields);
6326     }
6327   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6328     constructor_unfilled_fields = 0;
6329
6330   /* Now output any pending elements which have become next.  */
6331   if (pending)
6332     output_pending_init_elements (0);
6333 }
6334
6335 /* Output any pending elements which have become next.
6336    As we output elements, constructor_unfilled_{fields,index}
6337    advances, which may cause other elements to become next;
6338    if so, they too are output.
6339
6340    If ALL is 0, we return when there are
6341    no more pending elements to output now.
6342
6343    If ALL is 1, we output space as necessary so that
6344    we can output all the pending elements.  */
6345
6346 static void
6347 output_pending_init_elements (all)
6348      int all;
6349 {
6350   struct init_node *elt = constructor_pending_elts;
6351   tree next;
6352
6353  retry:
6354
6355   /* Look thru the whole pending tree.
6356      If we find an element that should be output now,
6357      output it.  Otherwise, set NEXT to the element
6358      that comes first among those still pending.  */
6359
6360   next = 0;
6361   while (elt)
6362     {
6363       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6364         {
6365           if (tree_int_cst_equal (elt->purpose,
6366                                   constructor_unfilled_index))
6367             output_init_element (elt->value,
6368                                  TREE_TYPE (constructor_type),
6369                                  constructor_unfilled_index, 0);
6370           else if (tree_int_cst_lt (constructor_unfilled_index,
6371                                     elt->purpose))
6372             {
6373               /* Advance to the next smaller node.  */
6374               if (elt->left)
6375                 elt = elt->left;
6376               else
6377                 {
6378                   /* We have reached the smallest node bigger than the
6379                      current unfilled index.  Fill the space first.  */
6380                   next = elt->purpose;
6381                   break;
6382                 }
6383             }
6384           else
6385             {
6386               /* Advance to the next bigger node.  */
6387               if (elt->right)
6388                 elt = elt->right;
6389               else
6390                 {
6391                   /* We have reached the biggest node in a subtree.  Find
6392                      the parent of it, which is the next bigger node.  */
6393                   while (elt->parent && elt->parent->right == elt)
6394                     elt = elt->parent;
6395                   elt = elt->parent;
6396                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6397                                               elt->purpose))
6398                     {
6399                       next = elt->purpose;
6400                       break;
6401                     }
6402                 }
6403             }
6404         }
6405       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6406                || TREE_CODE (constructor_type) == UNION_TYPE)
6407         {
6408           tree ctor_unfilled_bitpos, elt_bitpos;
6409
6410           /* If the current record is complete we are done.  */
6411           if (constructor_unfilled_fields == 0)
6412             break;
6413
6414           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6415           elt_bitpos = bit_position (elt->purpose);
6416           /* We can't compare fields here because there might be empty
6417              fields in between.  */
6418           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6419             {
6420               constructor_unfilled_fields = elt->purpose;
6421               output_init_element (elt->value, TREE_TYPE (elt->purpose),
6422                                    elt->purpose, 0);
6423             }
6424           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6425             {
6426               /* Advance to the next smaller node.  */
6427               if (elt->left)
6428                 elt = elt->left;
6429               else
6430                 {
6431                   /* We have reached the smallest node bigger than the
6432                      current unfilled field.  Fill the space first.  */
6433                   next = elt->purpose;
6434                   break;
6435                 }
6436             }
6437           else
6438             {
6439               /* Advance to the next bigger node.  */
6440               if (elt->right)
6441                 elt = elt->right;
6442               else
6443                 {
6444                   /* We have reached the biggest node in a subtree.  Find
6445                      the parent of it, which is the next bigger node.  */
6446                   while (elt->parent && elt->parent->right == elt)
6447                     elt = elt->parent;
6448                   elt = elt->parent;
6449                   if (elt
6450                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
6451                                            bit_position (elt->purpose))))
6452                     {
6453                       next = elt->purpose;
6454                       break;
6455                     }
6456                 }
6457             }
6458         }
6459     }
6460
6461   /* Ordinarily return, but not if we want to output all
6462      and there are elements left.  */
6463   if (! (all && next != 0))
6464     return;
6465
6466   /* If it's not incremental, just skip over the gap, so that after
6467      jumping to retry we will output the next successive element.  */
6468   if (TREE_CODE (constructor_type) == RECORD_TYPE
6469       || TREE_CODE (constructor_type) == UNION_TYPE)
6470     constructor_unfilled_fields = next;
6471   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6472     constructor_unfilled_index = next;
6473
6474   /* ELT now points to the node in the pending tree with the next
6475      initializer to output.  */
6476   goto retry;
6477 }
6478 \f
6479 /* Add one non-braced element to the current constructor level.
6480    This adjusts the current position within the constructor's type.
6481    This may also start or terminate implicit levels
6482    to handle a partly-braced initializer.
6483
6484    Once this has found the correct level for the new element,
6485    it calls output_init_element.  */
6486
6487 void
6488 process_init_element (value)
6489      tree value;
6490 {
6491   tree orig_value = value;
6492   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6493
6494   designator_depth = 0;
6495   designator_errorneous = 0;
6496
6497   /* Handle superfluous braces around string cst as in
6498      char x[] = {"foo"}; */
6499   if (string_flag
6500       && constructor_type
6501       && TREE_CODE (constructor_type) == ARRAY_TYPE
6502       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6503       && integer_zerop (constructor_unfilled_index))
6504     {
6505       if (constructor_stack->replacement_value)
6506         error_init ("excess elements in char array initializer");
6507       constructor_stack->replacement_value = value;
6508       return;
6509     }
6510
6511   if (constructor_stack->replacement_value != 0)
6512     {
6513       error_init ("excess elements in struct initializer");
6514       return;
6515     }
6516
6517   /* Ignore elements of a brace group if it is entirely superfluous
6518      and has already been diagnosed.  */
6519   if (constructor_type == 0)
6520     return;
6521
6522   /* If we've exhausted any levels that didn't have braces,
6523      pop them now.  */
6524   while (constructor_stack->implicit)
6525     {
6526       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6527            || TREE_CODE (constructor_type) == UNION_TYPE)
6528           && constructor_fields == 0)
6529         process_init_element (pop_init_level (1));
6530       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6531                && (constructor_max_index == 0
6532                    || tree_int_cst_lt (constructor_max_index,
6533                                        constructor_index)))
6534         process_init_element (pop_init_level (1));
6535       else
6536         break;
6537     }
6538
6539   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
6540   if (constructor_range_stack)
6541     {
6542       /* If value is a compound literal and we'll be just using its
6543          content, don't put it into a SAVE_EXPR.  */
6544       if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
6545           || !require_constant_value
6546           || flag_isoc99)
6547         value = save_expr (value);
6548     }
6549
6550   while (1)
6551     {
6552       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6553         {
6554           tree fieldtype;
6555           enum tree_code fieldcode;
6556
6557           if (constructor_fields == 0)
6558             {
6559               pedwarn_init ("excess elements in struct initializer");
6560               break;
6561             }
6562
6563           fieldtype = TREE_TYPE (constructor_fields);
6564           if (fieldtype != error_mark_node)
6565             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6566           fieldcode = TREE_CODE (fieldtype);
6567
6568           /* Error for non-static initialization of a flexible array member.  */
6569           if (fieldcode == ARRAY_TYPE
6570               && !require_constant_value
6571               && TYPE_SIZE (fieldtype) == NULL_TREE
6572               && TREE_CHAIN (constructor_fields) == NULL_TREE)
6573             {
6574               error_init ("non-static initialization of a flexible array member");
6575               break;
6576             }
6577
6578           /* Accept a string constant to initialize a subarray.  */
6579           if (value != 0
6580               && fieldcode == ARRAY_TYPE
6581               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6582               && string_flag)
6583             value = orig_value;
6584           /* Otherwise, if we have come to a subaggregate,
6585              and we don't have an element of its type, push into it.  */
6586           else if (value != 0 && !constructor_no_implicit
6587                    && value != error_mark_node
6588                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6589                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6590                        || fieldcode == UNION_TYPE))
6591             {
6592               push_init_level (1);
6593               continue;
6594             }
6595
6596           if (value)
6597             {
6598               push_member_name (constructor_fields);
6599               output_init_element (value, fieldtype, constructor_fields, 1);
6600               RESTORE_SPELLING_DEPTH (constructor_depth);
6601             }
6602           else
6603             /* Do the bookkeeping for an element that was
6604                directly output as a constructor.  */
6605             {
6606               /* For a record, keep track of end position of last field.  */
6607               if (DECL_SIZE (constructor_fields))
6608                 constructor_bit_index
6609                   = size_binop (PLUS_EXPR,
6610                                 bit_position (constructor_fields),
6611                                 DECL_SIZE (constructor_fields));
6612
6613               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6614               /* Skip any nameless bit fields.  */
6615               while (constructor_unfilled_fields != 0
6616                      && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6617                      && DECL_NAME (constructor_unfilled_fields) == 0)
6618                 constructor_unfilled_fields =
6619                   TREE_CHAIN (constructor_unfilled_fields);
6620             }
6621
6622           constructor_fields = TREE_CHAIN (constructor_fields);
6623           /* Skip any nameless bit fields at the beginning.  */
6624           while (constructor_fields != 0
6625                  && DECL_C_BIT_FIELD (constructor_fields)
6626                  && DECL_NAME (constructor_fields) == 0)
6627             constructor_fields = TREE_CHAIN (constructor_fields);
6628         }
6629       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6630         {
6631           tree fieldtype;
6632           enum tree_code fieldcode;
6633
6634           if (constructor_fields == 0)
6635             {
6636               pedwarn_init ("excess elements in union initializer");
6637               break;
6638             }
6639
6640           fieldtype = TREE_TYPE (constructor_fields);
6641           if (fieldtype != error_mark_node)
6642             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6643           fieldcode = TREE_CODE (fieldtype);
6644
6645           /* Warn that traditional C rejects initialization of unions.
6646              We skip the warning if the value is zero.  This is done
6647              under the assumption that the zero initializer in user
6648              code appears conditioned on e.g. __STDC__ to avoid
6649              "missing initializer" warnings and relies on default
6650              initialization to zero in the traditional C case.
6651              We also skip the warning if the initializer is designated,
6652              again on the assumption that this must be conditional on
6653              __STDC__ anyway (and we've already complained about the
6654              member-designator already).  */
6655           if (warn_traditional && !in_system_header && !constructor_designated
6656               && !(value && (integer_zerop (value) || real_zerop (value))))
6657             warning ("traditional C rejects initialization of unions");
6658
6659           /* Accept a string constant to initialize a subarray.  */
6660           if (value != 0
6661               && fieldcode == ARRAY_TYPE
6662               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6663               && string_flag)
6664             value = orig_value;
6665           /* Otherwise, if we have come to a subaggregate,
6666              and we don't have an element of its type, push into it.  */
6667           else if (value != 0 && !constructor_no_implicit
6668                    && value != error_mark_node
6669                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6670                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6671                        || fieldcode == UNION_TYPE))
6672             {
6673               push_init_level (1);
6674               continue;
6675             }
6676
6677           if (value)
6678             {
6679               push_member_name (constructor_fields);
6680               output_init_element (value, fieldtype, constructor_fields, 1);
6681               RESTORE_SPELLING_DEPTH (constructor_depth);
6682             }
6683           else
6684             /* Do the bookkeeping for an element that was
6685                directly output as a constructor.  */
6686             {
6687               constructor_bit_index = DECL_SIZE (constructor_fields);
6688               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6689             }
6690
6691           constructor_fields = 0;
6692         }
6693       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6694         {
6695           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6696           enum tree_code eltcode = TREE_CODE (elttype);
6697
6698           /* Accept a string constant to initialize a subarray.  */
6699           if (value != 0
6700               && eltcode == ARRAY_TYPE
6701               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6702               && string_flag)
6703             value = orig_value;
6704           /* Otherwise, if we have come to a subaggregate,
6705              and we don't have an element of its type, push into it.  */
6706           else if (value != 0 && !constructor_no_implicit
6707                    && value != error_mark_node
6708                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6709                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6710                        || eltcode == UNION_TYPE))
6711             {
6712               push_init_level (1);
6713               continue;
6714             }
6715
6716           if (constructor_max_index != 0
6717               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6718                   || integer_all_onesp (constructor_max_index)))
6719             {
6720               pedwarn_init ("excess elements in array initializer");
6721               break;
6722             }
6723
6724           /* Now output the actual element.  */
6725           if (value)
6726             {
6727               push_array_bounds (tree_low_cst (constructor_index, 0));
6728               output_init_element (value, elttype, constructor_index, 1);
6729               RESTORE_SPELLING_DEPTH (constructor_depth);
6730             }
6731
6732           constructor_index
6733             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6734
6735           if (! value)
6736             /* If we are doing the bookkeeping for an element that was
6737                directly output as a constructor, we must update
6738                constructor_unfilled_index.  */
6739             constructor_unfilled_index = constructor_index;
6740         }
6741       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6742         {
6743           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6744
6745          /* Do a basic check of initializer size.  Note that vectors
6746             always have a fixed size derived from their type.  */
6747           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6748             {
6749               pedwarn_init ("excess elements in vector initializer");
6750               break;
6751             }
6752
6753           /* Now output the actual element.  */
6754           if (value)
6755             output_init_element (value, elttype, constructor_index, 1);
6756
6757           constructor_index
6758             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6759
6760           if (! value)
6761             /* If we are doing the bookkeeping for an element that was
6762                directly output as a constructor, we must update
6763                constructor_unfilled_index.  */
6764             constructor_unfilled_index = constructor_index;
6765         }
6766
6767       /* Handle the sole element allowed in a braced initializer
6768          for a scalar variable.  */
6769       else if (constructor_fields == 0)
6770         {
6771           pedwarn_init ("excess elements in scalar initializer");
6772           break;
6773         }
6774       else
6775         {
6776           if (value)
6777             output_init_element (value, constructor_type, NULL_TREE, 1);
6778           constructor_fields = 0;
6779         }
6780
6781       /* Handle range initializers either at this level or anywhere higher
6782          in the designator stack.  */
6783       if (constructor_range_stack)
6784         {
6785           struct constructor_range_stack *p, *range_stack;
6786           int finish = 0;
6787
6788           range_stack = constructor_range_stack;
6789           constructor_range_stack = 0;
6790           while (constructor_stack != range_stack->stack)
6791             {
6792               if (!constructor_stack->implicit)
6793                 abort ();
6794               process_init_element (pop_init_level (1));
6795             }
6796           for (p = range_stack;
6797                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6798                p = p->prev)
6799             {
6800               if (!constructor_stack->implicit)
6801                 abort ();
6802               process_init_element (pop_init_level (1));
6803             }
6804
6805           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6806           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6807             finish = 1;
6808
6809           while (1)
6810             {
6811               constructor_index = p->index;
6812               constructor_fields = p->fields;
6813               if (finish && p->range_end && p->index == p->range_start)
6814                 {
6815                   finish = 0;
6816                   p->prev = 0;
6817                 }
6818               p = p->next;
6819               if (!p)
6820                 break;
6821               push_init_level (2);
6822               p->stack = constructor_stack;
6823               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6824                 p->index = p->range_start;
6825             }
6826
6827           if (!finish)
6828             constructor_range_stack = range_stack;
6829           continue;
6830         }
6831
6832       break;
6833     }
6834
6835   constructor_range_stack = 0;
6836 }
6837 \f
6838 /* Build a simple asm-statement, from one string literal.  */
6839 tree
6840 simple_asm_stmt (expr)
6841      tree expr;
6842 {
6843   STRIP_NOPS (expr);
6844
6845   if (TREE_CODE (expr) == ADDR_EXPR)
6846     expr = TREE_OPERAND (expr, 0);
6847
6848   if (TREE_CODE (expr) == STRING_CST)
6849     {
6850       tree stmt;
6851
6852       stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6853                                    NULL_TREE, NULL_TREE,
6854                                    NULL_TREE));
6855       ASM_INPUT_P (stmt) = 1;
6856       return stmt;
6857     }
6858
6859   error ("argument of `asm' is not a constant string");
6860   return NULL_TREE;
6861 }
6862
6863 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6864    STRING, some OUTPUTS, some INPUTS, and some CLOBBERS.  */
6865
6866 tree
6867 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6868      tree cv_qualifier;
6869      tree string;
6870      tree outputs;
6871      tree inputs;
6872      tree clobbers;
6873 {
6874   tree tail;
6875
6876   if (TREE_CODE (string) != STRING_CST)
6877     {
6878       error ("asm template is not a string constant");
6879       return NULL_TREE;
6880     }
6881
6882   if (cv_qualifier != NULL_TREE
6883       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6884     {
6885       warning ("%s qualifier ignored on asm",
6886                IDENTIFIER_POINTER (cv_qualifier));
6887       cv_qualifier = NULL_TREE;
6888     }
6889
6890   /* We can remove output conversions that change the type,
6891      but not the mode.  */
6892   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6893     {
6894       tree output = TREE_VALUE (tail);
6895
6896       STRIP_NOPS (output);
6897       TREE_VALUE (tail) = output;
6898
6899       /* Allow conversions as LHS here.  build_modify_expr as called below
6900          will do the right thing with them.  */
6901       while (TREE_CODE (output) == NOP_EXPR
6902              || TREE_CODE (output) == CONVERT_EXPR
6903              || TREE_CODE (output) == FLOAT_EXPR
6904              || TREE_CODE (output) == FIX_TRUNC_EXPR
6905              || TREE_CODE (output) == FIX_FLOOR_EXPR
6906              || TREE_CODE (output) == FIX_ROUND_EXPR
6907              || TREE_CODE (output) == FIX_CEIL_EXPR)
6908         output = TREE_OPERAND (output, 0);
6909
6910       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6911     }
6912
6913   /* Remove output conversions that change the type but not the mode.  */
6914   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6915     {
6916       tree output = TREE_VALUE (tail);
6917       STRIP_NOPS (output);
6918       TREE_VALUE (tail) = output;
6919     }
6920
6921   /* Perform default conversions on array and function inputs.
6922      Don't do this for other types as it would screw up operands
6923      expected to be in memory.  */
6924   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6925     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6926
6927   return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6928                                outputs, inputs, clobbers));
6929 }
6930
6931 /* Expand an ASM statement with operands, handling output operands
6932    that are not variables or INDIRECT_REFS by transforming such
6933    cases into cases that expand_asm_operands can handle.
6934
6935    Arguments are same as for expand_asm_operands.  */
6936
6937 void
6938 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6939      tree string, outputs, inputs, clobbers;
6940      int vol;
6941      const char *filename;
6942      int line;
6943 {
6944   int noutputs = list_length (outputs);
6945   int i;
6946   /* o[I] is the place that output number I should be written.  */
6947   tree *o = (tree *) alloca (noutputs * sizeof (tree));
6948   tree tail;
6949
6950   /* Record the contents of OUTPUTS before it is modified.  */
6951   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6952     o[i] = TREE_VALUE (tail);
6953
6954   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6955      OUTPUTS some trees for where the values were actually stored.  */
6956   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6957
6958   /* Copy all the intermediate outputs into the specified outputs.  */
6959   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6960     {
6961       if (o[i] != TREE_VALUE (tail))
6962         {
6963           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6964                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6965           free_temp_slots ();
6966
6967           /* Restore the original value so that it's correct the next
6968              time we expand this function.  */
6969           TREE_VALUE (tail) = o[i];
6970         }
6971       /* Detect modification of read-only values.
6972          (Otherwise done by build_modify_expr.)  */
6973       else
6974         {
6975           tree type = TREE_TYPE (o[i]);
6976           if (TREE_READONLY (o[i])
6977               || TYPE_READONLY (type)
6978               || ((TREE_CODE (type) == RECORD_TYPE
6979                    || TREE_CODE (type) == UNION_TYPE)
6980                   && C_TYPE_FIELDS_READONLY (type)))
6981             readonly_warning (o[i], "modification by `asm'");
6982         }
6983     }
6984
6985   /* Those MODIFY_EXPRs could do autoincrements.  */
6986   emit_queue ();
6987 }
6988 \f
6989 /* Expand a C `return' statement.
6990    RETVAL is the expression for what to return,
6991    or a null pointer for `return;' with no value.  */
6992
6993 tree
6994 c_expand_return (retval)
6995      tree retval;
6996 {
6997   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6998
6999   if (TREE_THIS_VOLATILE (current_function_decl))
7000     warning ("function declared `noreturn' has a `return' statement");
7001
7002   if (!retval)
7003     {
7004       current_function_returns_null = 1;
7005       if ((warn_return_type || flag_isoc99)
7006           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
7007         pedwarn_c99 ("`return' with no value, in function returning non-void");
7008     }
7009   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
7010     {
7011       current_function_returns_null = 1;
7012       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7013         pedwarn ("`return' with a value, in function returning void");
7014     }
7015   else
7016     {
7017       tree t = convert_for_assignment (valtype, retval, _("return"),
7018                                        NULL_TREE, NULL_TREE, 0);
7019       tree res = DECL_RESULT (current_function_decl);
7020       tree inner;
7021
7022       current_function_returns_value = 1;
7023       if (t == error_mark_node)
7024         return NULL_TREE;
7025
7026       inner = t = convert (TREE_TYPE (res), t);
7027
7028       /* Strip any conversions, additions, and subtractions, and see if
7029          we are returning the address of a local variable.  Warn if so.  */
7030       while (1)
7031         {
7032           switch (TREE_CODE (inner))
7033             {
7034             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
7035             case PLUS_EXPR:
7036               inner = TREE_OPERAND (inner, 0);
7037               continue;
7038
7039             case MINUS_EXPR:
7040               /* If the second operand of the MINUS_EXPR has a pointer
7041                  type (or is converted from it), this may be valid, so
7042                  don't give a warning.  */
7043               {
7044                 tree op1 = TREE_OPERAND (inner, 1);
7045
7046                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
7047                        && (TREE_CODE (op1) == NOP_EXPR
7048                            || TREE_CODE (op1) == NON_LVALUE_EXPR
7049                            || TREE_CODE (op1) == CONVERT_EXPR))
7050                   op1 = TREE_OPERAND (op1, 0);
7051
7052                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7053                   break;
7054
7055                 inner = TREE_OPERAND (inner, 0);
7056                 continue;
7057               }
7058
7059             case ADDR_EXPR:
7060               inner = TREE_OPERAND (inner, 0);
7061
7062               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
7063                 inner = TREE_OPERAND (inner, 0);
7064
7065               if (TREE_CODE (inner) == VAR_DECL
7066                   && ! DECL_EXTERNAL (inner)
7067                   && ! TREE_STATIC (inner)
7068                   && DECL_CONTEXT (inner) == current_function_decl)
7069                 warning ("function returns address of local variable");
7070               break;
7071
7072             default:
7073               break;
7074             }
7075
7076           break;
7077         }
7078
7079       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
7080     }
7081
7082  return add_stmt (build_return_stmt (retval));
7083 }
7084 \f
7085 struct c_switch {
7086   /* The SWITCH_STMT being built.  */
7087   tree switch_stmt;
7088   /* A splay-tree mapping the low element of a case range to the high
7089      element, or NULL_TREE if there is no high element.  Used to
7090      determine whether or not a new case label duplicates an old case
7091      label.  We need a tree, rather than simply a hash table, because
7092      of the GNU case range extension.  */
7093   splay_tree cases;
7094   /* The next node on the stack.  */
7095   struct c_switch *next;
7096 };
7097
7098 /* A stack of the currently active switch statements.  The innermost
7099    switch statement is on the top of the stack.  There is no need to
7100    mark the stack for garbage collection because it is only active
7101    during the processing of the body of a function, and we never
7102    collect at that point.  */
7103
7104 static struct c_switch *switch_stack;
7105
7106 /* Start a C switch statement, testing expression EXP.  Return the new
7107    SWITCH_STMT.  */
7108
7109 tree
7110 c_start_case (exp)
7111      tree exp;
7112 {
7113   enum tree_code code;
7114   tree type, orig_type = error_mark_node;
7115   struct c_switch *cs;
7116
7117   if (exp != error_mark_node)
7118     {
7119       code = TREE_CODE (TREE_TYPE (exp));
7120       orig_type = TREE_TYPE (exp);
7121
7122       if (! INTEGRAL_TYPE_P (orig_type)
7123           && code != ERROR_MARK)
7124         {
7125           error ("switch quantity not an integer");
7126           exp = integer_zero_node;
7127         }
7128       else
7129         {
7130           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7131
7132           if (warn_traditional && !in_system_header
7133               && (type == long_integer_type_node
7134                   || type == long_unsigned_type_node))
7135             warning ("`long' switch expression not converted to `int' in ISO C");
7136
7137           exp = default_conversion (exp);
7138           type = TREE_TYPE (exp);
7139         }
7140     }
7141
7142   /* Add this new SWITCH_STMT to the stack.  */
7143   cs = (struct c_switch *) xmalloc (sizeof (*cs));
7144   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
7145   cs->cases = splay_tree_new (case_compare, NULL, NULL);
7146   cs->next = switch_stack;
7147   switch_stack = cs;
7148
7149   return add_stmt (switch_stack->switch_stmt);
7150 }
7151
7152 /* Process a case label.  */
7153
7154 tree
7155 do_case (low_value, high_value)
7156      tree low_value;
7157      tree high_value;
7158 {
7159   tree label = NULL_TREE;
7160
7161   if (switch_stack)
7162     {
7163       label = c_add_case_label (switch_stack->cases,
7164                                 SWITCH_COND (switch_stack->switch_stmt),
7165                                 low_value, high_value);
7166       if (label == error_mark_node)
7167         label = NULL_TREE;
7168     }
7169   else if (low_value)
7170     error ("case label not within a switch statement");
7171   else
7172     error ("`default' label not within a switch statement");
7173
7174   return label;
7175 }
7176
7177 /* Finish the switch statement.  */
7178
7179 void
7180 c_finish_case ()
7181 {
7182   struct c_switch *cs = switch_stack;
7183
7184   RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7185
7186   /* Pop the stack.  */
7187   switch_stack = switch_stack->next;
7188   splay_tree_delete (cs->cases);
7189   free (cs);
7190 }