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