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