gcc/c-typeck.c

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