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