gcc/c-typeck.c

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