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       if (TREE_CODE (type) == POINTER_TYPE
3763           && TREE_CODE (otype) == POINTER_TYPE
3764           && TREE_CODE (expr) == ADDR_EXPR
3765           && DECL_P (TREE_OPERAND (expr, 0))
3766           && flag_strict_aliasing && warn_strict_aliasing
3767           && !VOID_TYPE_P (TREE_TYPE (type)))
3768         {
3769           /* Casting the address of a decl to non void pointer. Warn
3770              if the cast breaks type based aliasing.  */
3771           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3772             warning ("type-punning to incomplete type might break strict-aliasing rules");
3773           else if (!alias_sets_conflict_p
3774                    (get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0))),
3775                     get_alias_set (TREE_TYPE (type))))
3776             warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3777         }
3778
3779       ovalue = value;
3780       value = convert (type, value);
3781
3782       /* Ignore any integer overflow caused by the cast.  */
3783       if (TREE_CODE (value) == INTEGER_CST)
3784         {
3785           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3786           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3787         }
3788     }
3789
3790   /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant.  */
3791   if (pedantic && TREE_CODE (value) == INTEGER_CST
3792       && TREE_CODE (expr) == INTEGER_CST
3793       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3794     value = non_lvalue (value);
3795
3796   /* If pedantic, don't let a cast be an lvalue.  */
3797   if (value == expr && pedantic)
3798     value = non_lvalue (value);
3799
3800   return value;
3801 }
3802
3803 /* Interpret a cast of expression EXPR to type TYPE.  */
3804 tree
3805 c_cast_expr (type, expr)
3806      tree type, expr;
3807 {
3808   int saved_wsp = warn_strict_prototypes;
3809
3810   /* This avoids warnings about unprototyped casts on
3811      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3812   if (TREE_CODE (expr) == INTEGER_CST)
3813     warn_strict_prototypes = 0;
3814   type = groktypename (type);
3815   warn_strict_prototypes = saved_wsp;
3816
3817   return build_c_cast (type, expr);
3818 }
3819
3820 \f
3821 /* Build an assignment expression of lvalue LHS from value RHS.
3822    MODIFYCODE is the code for a binary operator that we use
3823    to combine the old value of LHS with RHS to get the new value.
3824    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3825
3826 tree
3827 build_modify_expr (lhs, modifycode, rhs)
3828      tree lhs, rhs;
3829      enum tree_code modifycode;
3830 {
3831   tree result;
3832   tree newrhs;
3833   tree lhstype = TREE_TYPE (lhs);
3834   tree olhstype = lhstype;
3835
3836   /* Types that aren't fully specified cannot be used in assignments.  */
3837   lhs = require_complete_type (lhs);
3838
3839   /* Avoid duplicate error messages from operands that had errors.  */
3840   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3841     return error_mark_node;
3842
3843   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3844   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3845      whose value is 0 to count as a null pointer constant.  */
3846   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3847     rhs = TREE_OPERAND (rhs, 0);
3848
3849   newrhs = rhs;
3850
3851   /* Handle control structure constructs used as "lvalues".  */
3852
3853   switch (TREE_CODE (lhs))
3854     {
3855       /* Handle (a, b) used as an "lvalue".  */
3856     case COMPOUND_EXPR:
3857       pedantic_lvalue_warning (COMPOUND_EXPR);
3858       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3859       if (TREE_CODE (newrhs) == ERROR_MARK)
3860         return error_mark_node;
3861       return build (COMPOUND_EXPR, lhstype,
3862                     TREE_OPERAND (lhs, 0), newrhs);
3863
3864       /* Handle (a ? b : c) used as an "lvalue".  */
3865     case COND_EXPR:
3866       pedantic_lvalue_warning (COND_EXPR);
3867       rhs = save_expr (rhs);
3868       {
3869         /* Produce (a ? (b = rhs) : (c = rhs))
3870            except that the RHS goes through a save-expr
3871            so the code to compute it is only emitted once.  */
3872         tree cond
3873           = build_conditional_expr (TREE_OPERAND (lhs, 0),
3874                                     build_modify_expr (TREE_OPERAND (lhs, 1),
3875                                                        modifycode, rhs),
3876                                     build_modify_expr (TREE_OPERAND (lhs, 2),
3877                                                        modifycode, rhs));
3878         if (TREE_CODE (cond) == ERROR_MARK)
3879           return cond;
3880         /* Make sure the code to compute the rhs comes out
3881            before the split.  */
3882         return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3883                       /* But cast it to void to avoid an "unused" error.  */
3884                       convert (void_type_node, rhs), cond);
3885       }
3886     default:
3887       break;
3888     }
3889
3890   /* If a binary op has been requested, combine the old LHS value with the RHS
3891      producing the value we should actually store into the LHS.  */
3892
3893   if (modifycode != NOP_EXPR)
3894     {
3895       lhs = stabilize_reference (lhs);
3896       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3897     }
3898
3899   /* Handle a cast used as an "lvalue".
3900      We have already performed any binary operator using the value as cast.
3901      Now convert the result to the cast type of the lhs,
3902      and then true type of the lhs and store it there;
3903      then convert result back to the cast type to be the value
3904      of the assignment.  */
3905
3906   switch (TREE_CODE (lhs))
3907     {
3908     case NOP_EXPR:
3909     case CONVERT_EXPR:
3910     case FLOAT_EXPR:
3911     case FIX_TRUNC_EXPR:
3912     case FIX_FLOOR_EXPR:
3913     case FIX_ROUND_EXPR:
3914     case FIX_CEIL_EXPR:
3915       newrhs = default_function_array_conversion (newrhs);
3916       {
3917         tree inner_lhs = TREE_OPERAND (lhs, 0);
3918         tree result;
3919         result = build_modify_expr (inner_lhs, NOP_EXPR,
3920                                     convert (TREE_TYPE (inner_lhs),
3921                                              convert (lhstype, newrhs)));
3922         if (TREE_CODE (result) == ERROR_MARK)
3923           return result;
3924         pedantic_lvalue_warning (CONVERT_EXPR);
3925         return convert (TREE_TYPE (lhs), result);
3926       }
3927
3928     default:
3929       break;
3930     }
3931
3932   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3933      Reject anything strange now.  */
3934
3935   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3936     return error_mark_node;
3937
3938   /* Warn about storing in something that is `const'.  */
3939
3940   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3941       || ((TREE_CODE (lhstype) == RECORD_TYPE
3942            || TREE_CODE (lhstype) == UNION_TYPE)
3943           && C_TYPE_FIELDS_READONLY (lhstype)))
3944     readonly_warning (lhs, "assignment");
3945
3946   /* If storing into a structure or union member,
3947      it has probably been given type `int'.
3948      Compute the type that would go with
3949      the actual amount of storage the member occupies.  */
3950
3951   if (TREE_CODE (lhs) == COMPONENT_REF
3952       && (TREE_CODE (lhstype) == INTEGER_TYPE
3953           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3954           || TREE_CODE (lhstype) == REAL_TYPE
3955           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3956     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3957
3958   /* If storing in a field that is in actuality a short or narrower than one,
3959      we must store in the field in its actual type.  */
3960
3961   if (lhstype != TREE_TYPE (lhs))
3962     {
3963       lhs = copy_node (lhs);
3964       TREE_TYPE (lhs) = lhstype;
3965     }
3966
3967   /* Convert new value to destination type.  */
3968
3969   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3970                                    NULL_TREE, NULL_TREE, 0);
3971   if (TREE_CODE (newrhs) == ERROR_MARK)
3972     return error_mark_node;
3973
3974   /* Scan operands */
3975
3976   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3977   TREE_SIDE_EFFECTS (result) = 1;
3978
3979   /* If we got the LHS in a different type for storing in,
3980      convert the result back to the nominal type of LHS
3981      so that the value we return always has the same type
3982      as the LHS argument.  */
3983
3984   if (olhstype == TREE_TYPE (result))
3985     return result;
3986   return convert_for_assignment (olhstype, result, _("assignment"),
3987                                  NULL_TREE, NULL_TREE, 0);
3988 }
3989 \f
3990 /* Convert value RHS to type TYPE as preparation for an assignment
3991    to an lvalue of type TYPE.
3992    The real work of conversion is done by `convert'.
3993    The purpose of this function is to generate error messages
3994    for assignments that are not allowed in C.
3995    ERRTYPE is a string to use in error messages:
3996    "assignment", "return", etc.  If it is null, this is parameter passing
3997    for a function call (and different error messages are output).
3998
3999    FUNNAME is the name of the function being called,
4000    as an IDENTIFIER_NODE, or null.
4001    PARMNUM is the number of the argument, for printing in error messages.  */
4002
4003 static tree
4004 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4005      tree type, rhs;
4006      const char *errtype;
4007      tree fundecl, funname;
4008      int parmnum;
4009 {
4010   enum tree_code codel = TREE_CODE (type);
4011   tree rhstype;
4012   enum tree_code coder;
4013
4014   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4015   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4016      whose value is 0 to count as a null pointer constant.  */
4017   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4018     rhs = TREE_OPERAND (rhs, 0);
4019
4020   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4021       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4022     rhs = default_conversion (rhs);
4023   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4024     rhs = decl_constant_value_for_broken_optimization (rhs);
4025
4026   rhstype = TREE_TYPE (rhs);
4027   coder = TREE_CODE (rhstype);
4028
4029   if (coder == ERROR_MARK)
4030     return error_mark_node;
4031
4032   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4033     {
4034       overflow_warning (rhs);
4035       /* Check for Objective-C protocols.  This will automatically
4036          issue a warning if there are protocol violations.  No need to
4037          use the return value.  */
4038       if (flag_objc)
4039         objc_comptypes (type, rhstype, 0);
4040       return rhs;
4041     }
4042
4043   if (coder == VOID_TYPE)
4044     {
4045       error ("void value not ignored as it ought to be");
4046       return error_mark_node;
4047     }
4048   /* A type converts to a reference to it.
4049      This code doesn't fully support references, it's just for the
4050      special case of va_start and va_copy.  */
4051   if (codel == REFERENCE_TYPE
4052       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4053     {
4054       if (!lvalue_p (rhs))
4055         {
4056           error ("cannot pass rvalue to reference parameter");
4057           return error_mark_node;
4058         }
4059       if (!c_mark_addressable (rhs))
4060         return error_mark_node;
4061       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4062
4063       /* We already know that these two types are compatible, but they
4064          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
4065          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4066          likely to be va_list, a typedef to __builtin_va_list, which
4067          is different enough that it will cause problems later.  */
4068       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4069         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4070
4071       rhs = build1 (NOP_EXPR, type, rhs);
4072       return rhs;
4073     }
4074   /* Arithmetic types all interconvert, and enum is treated like int.  */
4075   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4076             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4077             || codel == BOOLEAN_TYPE)
4078            && (coder == INTEGER_TYPE || coder == REAL_TYPE
4079                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4080                || coder == BOOLEAN_TYPE))
4081     return convert_and_check (type, rhs);
4082
4083   /* Conversion to a transparent union from its member types.
4084      This applies only to function arguments.  */
4085   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4086     {
4087       tree memb_types;
4088       tree marginal_memb_type = 0;
4089
4090       for (memb_types = TYPE_FIELDS (type); memb_types;
4091            memb_types = TREE_CHAIN (memb_types))
4092         {
4093           tree memb_type = TREE_TYPE (memb_types);
4094
4095           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4096                          TYPE_MAIN_VARIANT (rhstype)))
4097             break;
4098
4099           if (TREE_CODE (memb_type) != POINTER_TYPE)
4100             continue;
4101
4102           if (coder == POINTER_TYPE)
4103             {
4104               tree ttl = TREE_TYPE (memb_type);
4105               tree ttr = TREE_TYPE (rhstype);
4106
4107               /* Any non-function converts to a [const][volatile] void *
4108                  and vice versa; otherwise, targets must be the same.
4109                  Meanwhile, the lhs target must have all the qualifiers of
4110                  the rhs.  */
4111               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4112                   || comp_target_types (memb_type, rhstype, 0))
4113                 {
4114                   /* If this type won't generate any warnings, use it.  */
4115                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4116                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
4117                            && TREE_CODE (ttl) == FUNCTION_TYPE)
4118                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4119                              == TYPE_QUALS (ttr))
4120                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4121                              == TYPE_QUALS (ttl))))
4122                     break;
4123
4124                   /* Keep looking for a better type, but remember this one.  */
4125                   if (! marginal_memb_type)
4126                     marginal_memb_type = memb_type;
4127                 }
4128             }
4129
4130           /* Can convert integer zero to any pointer type.  */
4131           if (integer_zerop (rhs)
4132               || (TREE_CODE (rhs) == NOP_EXPR
4133                   && integer_zerop (TREE_OPERAND (rhs, 0))))
4134             {
4135               rhs = null_pointer_node;
4136               break;
4137             }
4138         }
4139
4140       if (memb_types || marginal_memb_type)
4141         {
4142           if (! memb_types)
4143             {
4144               /* We have only a marginally acceptable member type;
4145                  it needs a warning.  */
4146               tree ttl = TREE_TYPE (marginal_memb_type);
4147               tree ttr = TREE_TYPE (rhstype);
4148
4149               /* Const and volatile mean something different for function
4150                  types, so the usual warnings are not appropriate.  */
4151               if (TREE_CODE (ttr) == FUNCTION_TYPE
4152                   && TREE_CODE (ttl) == FUNCTION_TYPE)
4153                 {
4154                   /* Because const and volatile on functions are
4155                      restrictions that say the function will not do
4156                      certain things, it is okay to use a const or volatile
4157                      function where an ordinary one is wanted, but not
4158                      vice-versa.  */
4159                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4160                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
4161                                          errtype, funname, parmnum);
4162                 }
4163               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4164                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4165                                      errtype, funname,
4166                                      parmnum);
4167             }
4168
4169           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4170             pedwarn ("ISO C prohibits argument conversion to union type");
4171
4172           return build1 (NOP_EXPR, type, rhs);
4173         }
4174     }
4175
4176   /* Conversions among pointers */
4177   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4178            && (coder == codel))
4179     {
4180       tree ttl = TREE_TYPE (type);
4181       tree ttr = TREE_TYPE (rhstype);
4182
4183       /* Any non-function converts to a [const][volatile] void *
4184          and vice versa; otherwise, targets must be the same.
4185          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4186       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4187           || comp_target_types (type, rhstype, 0)
4188           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
4189               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4190         {
4191           if (pedantic
4192               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4193                   ||
4194                   (VOID_TYPE_P (ttr)
4195                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
4196                       which are not ANSI null ptr constants.  */
4197                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4198                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4199             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4200                                  errtype, funname, parmnum);
4201           /* Const and volatile mean something different for function types,
4202              so the usual warnings are not appropriate.  */
4203           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4204                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4205             {
4206               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4207                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4208                                      errtype, funname, parmnum);
4209               /* If this is not a case of ignoring a mismatch in signedness,
4210                  no warning.  */
4211               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4212                        || comp_target_types (type, rhstype, 0))
4213                 ;
4214               /* If there is a mismatch, do warn.  */
4215               else if (pedantic)
4216                 warn_for_assignment ("pointer targets in %s differ in signedness",
4217                                      errtype, funname, parmnum);
4218             }
4219           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4220                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4221             {
4222               /* Because const and volatile on functions are restrictions
4223                  that say the function will not do certain things,
4224                  it is okay to use a const or volatile function
4225                  where an ordinary one is wanted, but not vice-versa.  */
4226               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4227                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4228                                      errtype, funname, parmnum);
4229             }
4230         }
4231       else
4232         warn_for_assignment ("%s from incompatible pointer type",
4233                              errtype, funname, parmnum);
4234       return convert (type, rhs);
4235     }
4236   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4237     {
4238       /* An explicit constant 0 can convert to a pointer,
4239          or one that results from arithmetic, even including
4240          a cast to integer type.  */
4241       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4242           &&
4243           ! (TREE_CODE (rhs) == NOP_EXPR
4244              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4245              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4246              && integer_zerop (TREE_OPERAND (rhs, 0))))
4247         {
4248           warn_for_assignment ("%s makes pointer from integer without a cast",
4249                                errtype, funname, parmnum);
4250           return convert (type, rhs);
4251         }
4252       return null_pointer_node;
4253     }
4254   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4255     {
4256       warn_for_assignment ("%s makes integer from pointer without a cast",
4257                            errtype, funname, parmnum);
4258       return convert (type, rhs);
4259     }
4260   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4261     return convert (type, rhs);
4262
4263   if (!errtype)
4264     {
4265       if (funname)
4266         {
4267           tree selector = objc_message_selector ();
4268
4269           if (selector && parmnum > 2)
4270             error ("incompatible type for argument %d of `%s'",
4271                    parmnum - 2, IDENTIFIER_POINTER (selector));
4272           else
4273             error ("incompatible type for argument %d of `%s'",
4274                    parmnum, IDENTIFIER_POINTER (funname));
4275         }
4276       else
4277         error ("incompatible type for argument %d of indirect function call",
4278                parmnum);
4279     }
4280   else
4281     error ("incompatible types in %s", errtype);
4282
4283   return error_mark_node;
4284 }
4285
4286 /* Convert VALUE for assignment into inlined parameter PARM.  */
4287
4288 tree
4289 c_convert_parm_for_inlining (parm, value, fn)
4290      tree parm, value, fn;
4291 {
4292   tree ret, type;
4293
4294   /* If FN was prototyped, the value has been converted already
4295      in convert_arguments.  */
4296   if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
4297     return value;
4298
4299   type = TREE_TYPE (parm);
4300   ret = convert_for_assignment (type, value,
4301                                 (char *) 0 /* arg passing  */, fn,
4302                                 DECL_NAME (fn), 0);
4303   if (PROMOTE_PROTOTYPES
4304       && INTEGRAL_TYPE_P (type)
4305       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
4306     ret = default_conversion (ret);
4307   return ret;
4308 }
4309
4310 /* Print a warning using MSGID.
4311    It gets OPNAME as its one parameter.
4312    if OPNAME is null and ARGNUM is 0, it is replaced by "passing arg of `FUNCTION'".
4313    Otherwise if OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4314    FUNCTION and ARGNUM are handled specially if we are building an
4315    Objective-C selector.  */
4316
4317 static void
4318 warn_for_assignment (msgid, opname, function, argnum)
4319      const char *msgid;
4320      const char *opname;
4321      tree function;
4322      int argnum;
4323 {
4324   if (opname == 0)
4325     {
4326       tree selector = objc_message_selector ();
4327       char * new_opname;
4328
4329       if (selector && argnum > 2)
4330         {
4331           function = selector;
4332           argnum -= 2;
4333         }
4334       if (argnum == 0)
4335         {
4336           if (function)
4337             {
4338               /* Function name is known; supply it.  */
4339               const char *const argstring = _("passing arg of `%s'");
4340               new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4341                                             + strlen (argstring) + 1
4342                                             + 1);
4343               sprintf (new_opname, argstring,
4344                        IDENTIFIER_POINTER (function));
4345             }
4346           else
4347             {
4348               /* Function name unknown (call through ptr).  */
4349               const char *const argnofun = _("passing arg of pointer to function");
4350               new_opname = (char *) alloca (strlen (argnofun) + 1 + 1);
4351               sprintf (new_opname, argnofun);
4352             }
4353         }
4354       else if (function)
4355         {
4356           /* Function name is known; supply it.  */
4357           const char *const argstring = _("passing arg %d of `%s'");
4358           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4359                                         + strlen (argstring) + 1 + 25
4360                                         /*%d*/ + 1);
4361           sprintf (new_opname, argstring, argnum,
4362                    IDENTIFIER_POINTER (function));
4363         }
4364       else
4365         {
4366           /* Function name unknown (call through ptr); just give arg number.  */
4367           const char *const argnofun = _("passing arg %d of pointer to function");
4368           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4369           sprintf (new_opname, argnofun, argnum);
4370         }
4371       opname = new_opname;
4372     }
4373   pedwarn (msgid, opname);
4374 }
4375 \f
4376 /* If VALUE is a compound expr all of whose expressions are constant, then
4377    return its value.  Otherwise, return error_mark_node.
4378
4379    This is for handling COMPOUND_EXPRs as initializer elements
4380    which is allowed with a warning when -pedantic is specified.  */
4381
4382 static tree
4383 valid_compound_expr_initializer (value, endtype)
4384      tree value;
4385      tree endtype;
4386 {
4387   if (TREE_CODE (value) == COMPOUND_EXPR)
4388     {
4389       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4390           == error_mark_node)
4391         return error_mark_node;
4392       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4393                                               endtype);
4394     }
4395   else if (! TREE_CONSTANT (value)
4396            && ! initializer_constant_valid_p (value, endtype))
4397     return error_mark_node;
4398   else
4399     return value;
4400 }
4401 \f
4402 /* Perform appropriate conversions on the initial value of a variable,
4403    store it in the declaration DECL,
4404    and print any error messages that are appropriate.
4405    If the init is invalid, store an ERROR_MARK.  */
4406
4407 void
4408 store_init_value (decl, init)
4409      tree decl, init;
4410 {
4411   tree value, type;
4412
4413   /* If variable's type was invalidly declared, just ignore it.  */
4414
4415   type = TREE_TYPE (decl);
4416   if (TREE_CODE (type) == ERROR_MARK)
4417     return;
4418
4419   /* Digest the specified initializer into an expression.  */
4420
4421   value = digest_init (type, init, TREE_STATIC (decl));
4422
4423   /* Store the expression if valid; else report error.  */
4424
4425 #if 0
4426   /* Note that this is the only place we can detect the error
4427      in a case such as   struct foo bar = (struct foo) { x, y };
4428      where there is one initial value which is a constructor expression.  */
4429   if (value == error_mark_node)
4430     ;
4431   else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4432     {
4433       error ("initializer for static variable is not constant");
4434       value = error_mark_node;
4435     }
4436   else if (TREE_STATIC (decl)
4437            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4438     {
4439       error ("initializer for static variable uses complicated arithmetic");
4440       value = error_mark_node;
4441     }
4442   else
4443     {
4444       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4445         {
4446           if (! TREE_CONSTANT (value))
4447             pedwarn ("aggregate initializer is not constant");
4448           else if (! TREE_STATIC (value))
4449             pedwarn ("aggregate initializer uses complicated arithmetic");
4450         }
4451     }
4452 #endif
4453
4454   if (warn_traditional && !in_system_header
4455       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4456     warning ("traditional C rejects automatic aggregate initialization");
4457
4458   DECL_INITIAL (decl) = value;
4459
4460   /* ANSI wants warnings about out-of-range constant initializers.  */
4461   STRIP_TYPE_NOPS (value);
4462   constant_expression_warning (value);
4463
4464   /* Check if we need to set array size from compound literal size.  */
4465   if (TREE_CODE (type) == ARRAY_TYPE
4466       && TYPE_DOMAIN (type) == 0
4467       && value != error_mark_node)
4468     {
4469       tree inside_init = init;
4470
4471       if (TREE_CODE (init) == NON_LVALUE_EXPR)
4472         inside_init = TREE_OPERAND (init, 0);
4473       inside_init = fold (inside_init);
4474
4475       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4476         {
4477           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4478
4479           if (TYPE_DOMAIN (TREE_TYPE (decl)))
4480             {
4481               /* For int foo[] = (int [3]){1}; we need to set array size
4482                  now since later on array initializer will be just the
4483                  brace enclosed list of the compound literal.  */
4484               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
4485               layout_type (type);
4486               layout_decl (decl, 0);
4487             }
4488         }
4489     }
4490 }
4491 \f
4492 /* Methods for storing and printing names for error messages.  */
4493
4494 /* Implement a spelling stack that allows components of a name to be pushed
4495    and popped.  Each element on the stack is this structure.  */
4496
4497 struct spelling
4498 {
4499   int kind;
4500   union
4501     {
4502       int i;
4503       const char *s;
4504     } u;
4505 };
4506
4507 #define SPELLING_STRING 1
4508 #define SPELLING_MEMBER 2
4509 #define SPELLING_BOUNDS 3
4510
4511 static struct spelling *spelling;       /* Next stack element (unused).  */
4512 static struct spelling *spelling_base;  /* Spelling stack base.  */
4513 static int spelling_size;               /* Size of the spelling stack.  */
4514
4515 /* Macros to save and restore the spelling stack around push_... functions.
4516    Alternative to SAVE_SPELLING_STACK.  */
4517
4518 #define SPELLING_DEPTH() (spelling - spelling_base)
4519 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4520
4521 /* Push an element on the spelling stack with type KIND and assign VALUE
4522    to MEMBER.  */
4523
4524 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4525 {                                                                       \
4526   int depth = SPELLING_DEPTH ();                                        \
4527                                                                         \
4528   if (depth >= spelling_size)                                           \
4529     {                                                                   \
4530       spelling_size += 10;                                              \
4531       if (spelling_base == 0)                                           \
4532         spelling_base                                                   \
4533           = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));     \
4534       else                                                              \
4535         spelling_base                                                   \
4536           = (struct spelling *) xrealloc (spelling_base,                \
4537                                           spelling_size * sizeof (struct spelling));    \
4538       RESTORE_SPELLING_DEPTH (depth);                                   \
4539     }                                                                   \
4540                                                                         \
4541   spelling->kind = (KIND);                                              \
4542   spelling->MEMBER = (VALUE);                                           \
4543   spelling++;                                                           \
4544 }
4545
4546 /* Push STRING on the stack.  Printed literally.  */
4547
4548 static void
4549 push_string (string)
4550      const char *string;
4551 {
4552   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4553 }
4554
4555 /* Push a member name on the stack.  Printed as '.' STRING.  */
4556
4557 static void
4558 push_member_name (decl)
4559      tree decl;
4560
4561 {
4562   const char *const string
4563     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4564   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4565 }
4566
4567 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4568
4569 static void
4570 push_array_bounds (bounds)
4571      int bounds;
4572 {
4573   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4574 }
4575
4576 /* Compute the maximum size in bytes of the printed spelling.  */
4577
4578 static int
4579 spelling_length ()
4580 {
4581   int size = 0;
4582   struct spelling *p;
4583
4584   for (p = spelling_base; p < spelling; p++)
4585     {
4586       if (p->kind == SPELLING_BOUNDS)
4587         size += 25;
4588       else
4589         size += strlen (p->u.s) + 1;
4590     }
4591
4592   return size;
4593 }
4594
4595 /* Print the spelling to BUFFER and return it.  */
4596
4597 static char *
4598 print_spelling (buffer)
4599      char *buffer;
4600 {
4601   char *d = buffer;
4602   struct spelling *p;
4603
4604   for (p = spelling_base; p < spelling; p++)
4605     if (p->kind == SPELLING_BOUNDS)
4606       {
4607         sprintf (d, "[%d]", p->u.i);
4608         d += strlen (d);
4609       }
4610     else
4611       {
4612         const char *s;
4613         if (p->kind == SPELLING_MEMBER)
4614           *d++ = '.';
4615         for (s = p->u.s; (*d = *s++); d++)
4616           ;
4617       }
4618   *d++ = '\0';
4619   return buffer;
4620 }
4621
4622 /* Issue an error message for a bad initializer component.
4623    MSGID identifies the message.
4624    The component name is taken from the spelling stack.  */
4625
4626 void
4627 error_init (msgid)
4628      const char *msgid;
4629 {
4630   char *ofwhat;
4631
4632   error ("%s", _(msgid));
4633   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4634   if (*ofwhat)
4635     error ("(near initialization for `%s')", ofwhat);
4636 }
4637
4638 /* Issue a pedantic warning for a bad initializer component.
4639    MSGID identifies the message.
4640    The component name is taken from the spelling stack.  */
4641
4642 void
4643 pedwarn_init (msgid)
4644      const char *msgid;
4645 {
4646   char *ofwhat;
4647
4648   pedwarn ("%s", _(msgid));
4649   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4650   if (*ofwhat)
4651     pedwarn ("(near initialization for `%s')", ofwhat);
4652 }
4653
4654 /* Issue a warning for a bad initializer component.
4655    MSGID identifies the message.
4656    The component name is taken from the spelling stack.  */
4657
4658 static void
4659 warning_init (msgid)
4660      const char *msgid;
4661 {
4662   char *ofwhat;
4663
4664   warning ("%s", _(msgid));
4665   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4666   if (*ofwhat)
4667     warning ("(near initialization for `%s')", ofwhat);
4668 }
4669 \f
4670 /* Digest the parser output INIT as an initializer for type TYPE.
4671    Return a C expression of type TYPE to represent the initial value.
4672
4673    REQUIRE_CONSTANT requests an error if non-constant initializers or
4674    elements are seen.  */
4675
4676 static tree
4677 digest_init (type, init, require_constant)
4678      tree type, init;
4679      int require_constant;
4680 {
4681   enum tree_code code = TREE_CODE (type);
4682   tree inside_init = init;
4683
4684   if (type == error_mark_node
4685       || init == error_mark_node
4686       || TREE_TYPE (init) == error_mark_node)
4687     return error_mark_node;
4688
4689   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4690   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4691      whose value is 0 to count as a null pointer constant.  */
4692   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4693     inside_init = TREE_OPERAND (init, 0);
4694
4695   inside_init = fold (inside_init);
4696
4697   /* Initialization of an array of chars from a string constant
4698      optionally enclosed in braces.  */
4699
4700   if (code == ARRAY_TYPE)
4701     {
4702       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4703       if ((typ1 == char_type_node
4704            || typ1 == signed_char_type_node
4705            || typ1 == unsigned_char_type_node
4706            || typ1 == unsigned_wchar_type_node
4707            || typ1 == signed_wchar_type_node)
4708           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4709         {
4710           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4711                          TYPE_MAIN_VARIANT (type)))
4712             return inside_init;
4713
4714           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4715                != char_type_node)
4716               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4717             {
4718               error_init ("char-array initialized from wide string");
4719               return error_mark_node;
4720             }
4721           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4722                == char_type_node)
4723               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4724             {
4725               error_init ("int-array initialized from non-wide string");
4726               return error_mark_node;
4727             }
4728
4729           TREE_TYPE (inside_init) = type;
4730           if (TYPE_DOMAIN (type) != 0
4731               && TYPE_SIZE (type) != 0
4732               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4733               /* Subtract 1 (or sizeof (wchar_t))
4734                  because it's ok to ignore the terminating null char
4735                  that is counted in the length of the constant.  */
4736               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4737                                        TREE_STRING_LENGTH (inside_init)
4738                                        - ((TYPE_PRECISION (typ1)
4739                                            != TYPE_PRECISION (char_type_node))
4740                                           ? (TYPE_PRECISION (wchar_type_node)
4741                                              / BITS_PER_UNIT)
4742                                           : 1)))
4743             pedwarn_init ("initializer-string for array of chars is too long");
4744
4745           return inside_init;
4746         }
4747     }
4748
4749   /* Any type can be initialized
4750      from an expression of the same type, optionally with braces.  */
4751
4752   if (inside_init && TREE_TYPE (inside_init) != 0
4753       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4754                      TYPE_MAIN_VARIANT (type))
4755           || (code == ARRAY_TYPE
4756               && comptypes (TREE_TYPE (inside_init), type))
4757           || (code == VECTOR_TYPE
4758               && comptypes (TREE_TYPE (inside_init), type))
4759           || (code == POINTER_TYPE
4760               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4761                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4762               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4763                             TREE_TYPE (type)))))
4764     {
4765       if (code == POINTER_TYPE)
4766         inside_init = default_function_array_conversion (inside_init);
4767
4768       if (require_constant && !flag_isoc99
4769           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4770         {
4771           /* As an extension, allow initializing objects with static storage
4772              duration with compound literals (which are then treated just as
4773              the brace enclosed list they contain).  */
4774           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4775           inside_init = DECL_INITIAL (decl);
4776         }
4777
4778       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4779           && TREE_CODE (inside_init) != CONSTRUCTOR)
4780         {
4781           error_init ("array initialized from non-constant array expression");
4782           return error_mark_node;
4783         }
4784
4785       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4786         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4787
4788       /* Compound expressions can only occur here if -pedantic or
4789          -pedantic-errors is specified.  In the later case, we always want
4790          an error.  In the former case, we simply want a warning.  */
4791       if (require_constant && pedantic
4792           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4793         {
4794           inside_init
4795             = valid_compound_expr_initializer (inside_init,
4796                                                TREE_TYPE (inside_init));
4797           if (inside_init == error_mark_node)
4798             error_init ("initializer element is not constant");
4799           else
4800             pedwarn_init ("initializer element is not constant");
4801           if (flag_pedantic_errors)
4802             inside_init = error_mark_node;
4803         }
4804       else if (require_constant
4805                && (!TREE_CONSTANT (inside_init)
4806                    /* This test catches things like `7 / 0' which
4807                       result in an expression for which TREE_CONSTANT
4808                       is true, but which is not actually something
4809                       that is a legal constant.  We really should not
4810                       be using this function, because it is a part of
4811                       the back-end.  Instead, the expression should
4812                       already have been turned into ERROR_MARK_NODE.  */
4813                    || !initializer_constant_valid_p (inside_init,
4814                                                      TREE_TYPE (inside_init))))
4815         {
4816           error_init ("initializer element is not constant");
4817           inside_init = error_mark_node;
4818         }
4819
4820       return inside_init;
4821     }
4822
4823   /* Handle scalar types, including conversions.  */
4824
4825   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4826       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4827     {
4828       /* Note that convert_for_assignment calls default_conversion
4829          for arrays and functions.  We must not call it in the
4830          case where inside_init is a null pointer constant.  */
4831       inside_init
4832         = convert_for_assignment (type, init, _("initialization"),
4833                                   NULL_TREE, NULL_TREE, 0);
4834
4835       if (require_constant && ! TREE_CONSTANT (inside_init))
4836         {
4837           error_init ("initializer element is not constant");
4838           inside_init = error_mark_node;
4839         }
4840       else if (require_constant
4841                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4842         {
4843           error_init ("initializer element is not computable at load time");
4844           inside_init = error_mark_node;
4845         }
4846
4847       return inside_init;
4848     }
4849
4850   /* Come here only for records and arrays.  */
4851
4852   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4853     {
4854       error_init ("variable-sized object may not be initialized");
4855       return error_mark_node;
4856     }
4857
4858   error_init ("invalid initializer");
4859   return error_mark_node;
4860 }
4861 \f
4862 /* Handle initializers that use braces.  */
4863
4864 /* Type of object we are accumulating a constructor for.
4865    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4866 static tree constructor_type;
4867
4868 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4869    left to fill.  */
4870 static tree constructor_fields;
4871
4872 /* For an ARRAY_TYPE, this is the specified index
4873    at which to store the next element we get.  */
4874 static tree constructor_index;
4875
4876 /* For an ARRAY_TYPE, this is the maximum index.  */
4877 static tree constructor_max_index;
4878
4879 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4880 static tree constructor_unfilled_fields;
4881
4882 /* For an ARRAY_TYPE, this is the index of the first element
4883    not yet written out.  */
4884 static tree constructor_unfilled_index;
4885
4886 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4887    This is so we can generate gaps between fields, when appropriate.  */
4888 static tree constructor_bit_index;
4889
4890 /* If we are saving up the elements rather than allocating them,
4891    this is the list of elements so far (in reverse order,
4892    most recent first).  */
4893 static tree constructor_elements;
4894
4895 /* 1 if constructor should be incrementally stored into a constructor chain,
4896    0 if all the elements should be kept in AVL tree.  */
4897 static int constructor_incremental;
4898
4899 /* 1 if so far this constructor's elements are all compile-time constants.  */
4900 static int constructor_constant;
4901
4902 /* 1 if so far this constructor's elements are all valid address constants.  */
4903 static int constructor_simple;
4904
4905 /* 1 if this constructor is erroneous so far.  */
4906 static int constructor_erroneous;
4907
4908 /* 1 if have called defer_addressed_constants.  */
4909 static int constructor_subconstants_deferred;
4910
4911 /* Structure for managing pending initializer elements, organized as an
4912    AVL tree.  */
4913
4914 struct init_node
4915 {
4916   struct init_node *left, *right;
4917   struct init_node *parent;
4918   int balance;
4919   tree purpose;
4920   tree value;
4921 };
4922
4923 /* Tree of pending elements at this constructor level.
4924    These are elements encountered out of order
4925    which belong at places we haven't reached yet in actually
4926    writing the output.
4927    Will never hold tree nodes across GC runs.  */
4928 static struct init_node *constructor_pending_elts;
4929
4930 /* The SPELLING_DEPTH of this constructor.  */
4931 static int constructor_depth;
4932
4933 /* 0 if implicitly pushing constructor levels is allowed.  */
4934 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4935
4936 static int require_constant_value;
4937 static int require_constant_elements;
4938
4939 /* DECL node for which an initializer is being read.
4940    0 means we are reading a constructor expression
4941    such as (struct foo) {...}.  */
4942 static tree constructor_decl;
4943
4944 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4945 static const char *constructor_asmspec;
4946
4947 /* Nonzero if this is an initializer for a top-level decl.  */
4948 static int constructor_top_level;
4949
4950 /* Nonzero if there were any member designators in this initializer.  */
4951 static int constructor_designated;
4952
4953 /* Nesting depth of designator list.  */
4954 static int designator_depth;
4955
4956 /* Nonzero if there were diagnosed errors in this designator list.  */
4957 static int designator_errorneous;
4958
4959 \f
4960 /* This stack has a level for each implicit or explicit level of
4961    structuring in the initializer, including the outermost one.  It
4962    saves the values of most of the variables above.  */
4963
4964 struct constructor_range_stack;
4965
4966 struct constructor_stack
4967 {
4968   struct constructor_stack *next;
4969   tree type;
4970   tree fields;
4971   tree index;
4972   tree max_index;
4973   tree unfilled_index;
4974   tree unfilled_fields;
4975   tree bit_index;
4976   tree elements;
4977   struct init_node *pending_elts;
4978   int offset;
4979   int depth;
4980   /* If nonzero, this value should replace the entire
4981      constructor at this level.  */
4982   tree replacement_value;
4983   struct constructor_range_stack *range_stack;
4984   char constant;
4985   char simple;
4986   char implicit;
4987   char erroneous;
4988   char outer;
4989   char incremental;
4990   char designated;
4991 };
4992
4993 struct constructor_stack *constructor_stack;
4994
4995 /* This stack represents designators from some range designator up to
4996    the last designator in the list.  */
4997
4998 struct constructor_range_stack
4999 {
5000   struct constructor_range_stack *next, *prev;
5001   struct constructor_stack *stack;
5002   tree range_start;
5003   tree index;
5004   tree range_end;
5005   tree fields;
5006 };
5007
5008 struct constructor_range_stack *constructor_range_stack;
5009
5010 /* This stack records separate initializers that are nested.
5011    Nested initializers can't happen in ANSI C, but GNU C allows them
5012    in cases like { ... (struct foo) { ... } ... }.  */
5013
5014 struct initializer_stack
5015 {
5016   struct initializer_stack *next;
5017   tree decl;
5018   const char *asmspec;
5019   struct constructor_stack *constructor_stack;
5020   struct constructor_range_stack *constructor_range_stack;
5021   tree elements;
5022   struct spelling *spelling;
5023   struct spelling *spelling_base;
5024   int spelling_size;
5025   char top_level;
5026   char require_constant_value;
5027   char require_constant_elements;
5028   char deferred;
5029 };
5030
5031 struct initializer_stack *initializer_stack;
5032 \f
5033 /* Prepare to parse and output the initializer for variable DECL.  */
5034
5035 void
5036 start_init (decl, asmspec_tree, top_level)
5037      tree decl;
5038      tree asmspec_tree;
5039      int top_level;
5040 {
5041   const char *locus;
5042   struct initializer_stack *p
5043     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5044   const char *asmspec = 0;
5045
5046   if (asmspec_tree)
5047     asmspec = TREE_STRING_POINTER (asmspec_tree);
5048
5049   p->decl = constructor_decl;
5050   p->asmspec = constructor_asmspec;
5051   p->require_constant_value = require_constant_value;
5052   p->require_constant_elements = require_constant_elements;
5053   p->constructor_stack = constructor_stack;
5054   p->constructor_range_stack = constructor_range_stack;
5055   p->elements = constructor_elements;
5056   p->spelling = spelling;
5057   p->spelling_base = spelling_base;
5058   p->spelling_size = spelling_size;
5059   p->deferred = constructor_subconstants_deferred;
5060   p->top_level = constructor_top_level;
5061   p->next = initializer_stack;
5062   initializer_stack = p;
5063
5064   constructor_decl = decl;
5065   constructor_asmspec = asmspec;
5066   constructor_subconstants_deferred = 0;
5067   constructor_designated = 0;
5068   constructor_top_level = top_level;
5069
5070   if (decl != 0)
5071     {
5072       require_constant_value = TREE_STATIC (decl);
5073       require_constant_elements
5074         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5075            /* For a scalar, you can always use any value to initialize,
5076               even within braces.  */
5077            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5078                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5079                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5080                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5081       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5082     }
5083   else
5084     {
5085       require_constant_value = 0;
5086       require_constant_elements = 0;
5087       locus = "(anonymous)";
5088     }
5089
5090   constructor_stack = 0;
5091   constructor_range_stack = 0;
5092
5093   missing_braces_mentioned = 0;
5094
5095   spelling_base = 0;
5096   spelling_size = 0;
5097   RESTORE_SPELLING_DEPTH (0);
5098
5099   if (locus)
5100     push_string (locus);
5101 }
5102
5103 void
5104 finish_init ()
5105 {
5106   struct initializer_stack *p = initializer_stack;
5107
5108   /* Output subconstants (string constants, usually)
5109      that were referenced within this initializer and saved up.
5110      Must do this if and only if we called defer_addressed_constants.  */
5111   if (constructor_subconstants_deferred)
5112     output_deferred_addressed_constants ();
5113
5114   /* Free the whole constructor stack of this initializer.  */
5115   while (constructor_stack)
5116     {
5117       struct constructor_stack *q = constructor_stack;
5118       constructor_stack = q->next;
5119       free (q);
5120     }
5121
5122   if (constructor_range_stack)
5123     abort ();
5124
5125   /* Pop back to the data of the outer initializer (if any).  */
5126   constructor_decl = p->decl;
5127   constructor_asmspec = p->asmspec;
5128   require_constant_value = p->require_constant_value;
5129   require_constant_elements = p->require_constant_elements;
5130   constructor_stack = p->constructor_stack;
5131   constructor_range_stack = p->constructor_range_stack;
5132   constructor_elements = p->elements;
5133   spelling = p->spelling;
5134   spelling_base = p->spelling_base;
5135   spelling_size = p->spelling_size;
5136   constructor_subconstants_deferred = p->deferred;
5137   constructor_top_level = p->top_level;
5138   initializer_stack = p->next;
5139   free (p);
5140 }
5141 \f
5142 /* Call here when we see the initializer is surrounded by braces.
5143    This is instead of a call to push_init_level;
5144    it is matched by a call to pop_init_level.
5145
5146    TYPE is the type to initialize, for a constructor expression.
5147    For an initializer for a decl, TYPE is zero.  */
5148
5149 void
5150 really_start_incremental_init (type)
5151      tree type;
5152 {
5153   struct constructor_stack *p
5154     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5155
5156   if (type == 0)
5157     type = TREE_TYPE (constructor_decl);
5158
5159   p->type = constructor_type;
5160   p->fields = constructor_fields;
5161   p->index = constructor_index;
5162   p->max_index = constructor_max_index;
5163   p->unfilled_index = constructor_unfilled_index;
5164   p->unfilled_fields = constructor_unfilled_fields;
5165   p->bit_index = constructor_bit_index;
5166   p->elements = constructor_elements;
5167   p->constant = constructor_constant;
5168   p->simple = constructor_simple;
5169   p->erroneous = constructor_erroneous;
5170   p->pending_elts = constructor_pending_elts;
5171   p->depth = constructor_depth;
5172   p->replacement_value = 0;
5173   p->implicit = 0;
5174   p->range_stack = 0;
5175   p->outer = 0;
5176   p->incremental = constructor_incremental;
5177   p->designated = constructor_designated;
5178   p->next = 0;
5179   constructor_stack = p;
5180
5181   constructor_constant = 1;
5182   constructor_simple = 1;
5183   constructor_depth = SPELLING_DEPTH ();
5184   constructor_elements = 0;
5185   constructor_pending_elts = 0;
5186   constructor_type = type;
5187   constructor_incremental = 1;
5188   constructor_designated = 0;
5189   designator_depth = 0;
5190   designator_errorneous = 0;
5191
5192   if (TREE_CODE (constructor_type) == RECORD_TYPE
5193       || TREE_CODE (constructor_type) == UNION_TYPE)
5194     {
5195       constructor_fields = TYPE_FIELDS (constructor_type);
5196       /* Skip any nameless bit fields at the beginning.  */
5197       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5198              && DECL_NAME (constructor_fields) == 0)
5199         constructor_fields = TREE_CHAIN (constructor_fields);
5200
5201       constructor_unfilled_fields = constructor_fields;
5202       constructor_bit_index = bitsize_zero_node;
5203     }
5204   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5205     {
5206       if (TYPE_DOMAIN (constructor_type))
5207         {
5208           constructor_max_index
5209             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5210
5211           /* Detect non-empty initializations of zero-length arrays.  */
5212           if (constructor_max_index == NULL_TREE
5213               && TYPE_SIZE (constructor_type))
5214             constructor_max_index = build_int_2 (-1, -1);
5215
5216           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
5217              to initialize VLAs will cause an proper error; avoid tree
5218              checking errors as well by setting a safe value.  */
5219           if (constructor_max_index
5220               && TREE_CODE (constructor_max_index) != INTEGER_CST)
5221             constructor_max_index = build_int_2 (-1, -1);
5222
5223           constructor_index
5224             = convert (bitsizetype,
5225                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5226         }
5227       else
5228         constructor_index = bitsize_zero_node;
5229
5230       constructor_unfilled_index = constructor_index;
5231     }
5232   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5233     {
5234       /* Vectors are like simple fixed-size arrays.  */
5235       constructor_max_index =
5236         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
5237       constructor_index = convert (bitsizetype, bitsize_zero_node);
5238       constructor_unfilled_index = constructor_index;
5239     }
5240   else
5241     {
5242       /* Handle the case of int x = {5}; */
5243       constructor_fields = constructor_type;
5244       constructor_unfilled_fields = constructor_type;
5245     }
5246 }
5247 \f
5248 /* Push down into a subobject, for initialization.
5249    If this is for an explicit set of braces, IMPLICIT is 0.
5250    If it is because the next element belongs at a lower level,
5251    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
5252
5253 void
5254 push_init_level (implicit)
5255      int implicit;
5256 {
5257   struct constructor_stack *p;
5258   tree value = NULL_TREE;
5259
5260   /* If we've exhausted any levels that didn't have braces,
5261      pop them now.  */
5262   while (constructor_stack->implicit)
5263     {
5264       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5265            || TREE_CODE (constructor_type) == UNION_TYPE)
5266           && constructor_fields == 0)
5267         process_init_element (pop_init_level (1));
5268       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5269                && tree_int_cst_lt (constructor_max_index, constructor_index))
5270         process_init_element (pop_init_level (1));
5271       else
5272         break;
5273     }
5274
5275   /* Unless this is an explicit brace, we need to preserve previous
5276      content if any.  */
5277   if (implicit)
5278     {
5279       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5280            || TREE_CODE (constructor_type) == UNION_TYPE)
5281           && constructor_fields)
5282         value = find_init_member (constructor_fields);
5283       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5284         value = find_init_member (constructor_index);
5285     }
5286
5287   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5288   p->type = constructor_type;
5289   p->fields = constructor_fields;
5290   p->index = constructor_index;
5291   p->max_index = constructor_max_index;
5292   p->unfilled_index = constructor_unfilled_index;
5293   p->unfilled_fields = constructor_unfilled_fields;
5294   p->bit_index = constructor_bit_index;
5295   p->elements = constructor_elements;
5296   p->constant = constructor_constant;
5297   p->simple = constructor_simple;
5298   p->erroneous = constructor_erroneous;
5299   p->pending_elts = constructor_pending_elts;
5300   p->depth = constructor_depth;
5301   p->replacement_value = 0;
5302   p->implicit = implicit;
5303   p->outer = 0;
5304   p->incremental = constructor_incremental;
5305   p->designated = constructor_designated;
5306   p->next = constructor_stack;
5307   p->range_stack = 0;
5308   constructor_stack = p;
5309
5310   constructor_constant = 1;
5311   constructor_simple = 1;
5312   constructor_depth = SPELLING_DEPTH ();
5313   constructor_elements = 0;
5314   constructor_incremental = 1;
5315   constructor_designated = 0;
5316   constructor_pending_elts = 0;
5317   if (!implicit)
5318     {
5319       p->range_stack = constructor_range_stack;
5320       constructor_range_stack = 0;
5321       designator_depth = 0;
5322       designator_errorneous = 0;
5323     }
5324
5325   /* Don't die if an entire brace-pair level is superfluous
5326      in the containing level.  */
5327   if (constructor_type == 0)
5328     ;
5329   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5330            || TREE_CODE (constructor_type) == UNION_TYPE)
5331     {
5332       /* Don't die if there are extra init elts at the end.  */
5333       if (constructor_fields == 0)
5334         constructor_type = 0;
5335       else
5336         {
5337           constructor_type = TREE_TYPE (constructor_fields);
5338           push_member_name (constructor_fields);
5339           constructor_depth++;
5340         }
5341     }
5342   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5343     {
5344       constructor_type = TREE_TYPE (constructor_type);
5345       push_array_bounds (tree_low_cst (constructor_index, 0));
5346       constructor_depth++;
5347     }
5348
5349   if (constructor_type == 0)
5350     {
5351       error_init ("extra brace group at end of initializer");
5352       constructor_fields = 0;
5353       constructor_unfilled_fields = 0;
5354       return;
5355     }
5356
5357   if (value && TREE_CODE (value) == CONSTRUCTOR)
5358     {
5359       constructor_constant = TREE_CONSTANT (value);
5360       constructor_simple = TREE_STATIC (value);
5361       constructor_elements = TREE_OPERAND (value, 1);
5362       if (constructor_elements
5363           && (TREE_CODE (constructor_type) == RECORD_TYPE
5364               || TREE_CODE (constructor_type) == ARRAY_TYPE))
5365         set_nonincremental_init ();
5366     }
5367
5368   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5369     {
5370       missing_braces_mentioned = 1;
5371       warning_init ("missing braces around initializer");
5372     }
5373
5374   if (TREE_CODE (constructor_type) == RECORD_TYPE
5375            || TREE_CODE (constructor_type) == UNION_TYPE)
5376     {
5377       constructor_fields = TYPE_FIELDS (constructor_type);
5378       /* Skip any nameless bit fields at the beginning.  */
5379       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5380              && DECL_NAME (constructor_fields) == 0)
5381         constructor_fields = TREE_CHAIN (constructor_fields);
5382
5383       constructor_unfilled_fields = constructor_fields;
5384       constructor_bit_index = bitsize_zero_node;
5385     }
5386   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5387     {
5388       /* Vectors are like simple fixed-size arrays.  */
5389       constructor_max_index =
5390         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
5391       constructor_index = convert (bitsizetype, integer_zero_node);
5392       constructor_unfilled_index = constructor_index;
5393     }
5394   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5395     {
5396       if (TYPE_DOMAIN (constructor_type))
5397         {
5398           constructor_max_index
5399             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5400
5401           /* Detect non-empty initializations of zero-length arrays.  */
5402           if (constructor_max_index == NULL_TREE
5403               && TYPE_SIZE (constructor_type))
5404             constructor_max_index = build_int_2 (-1, -1);
5405
5406           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
5407              to initialize VLAs will cause an proper error; avoid tree
5408              checking errors as well by setting a safe value.  */
5409           if (constructor_max_index
5410               && TREE_CODE (constructor_max_index) != INTEGER_CST)
5411             constructor_max_index = build_int_2 (-1, -1);
5412
5413           constructor_index
5414             = convert (bitsizetype,
5415                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5416         }
5417       else
5418         constructor_index = bitsize_zero_node;
5419
5420       constructor_unfilled_index = constructor_index;
5421       if (value && TREE_CODE (value) == STRING_CST)
5422         {
5423           /* We need to split the char/wchar array into individual
5424              characters, so that we don't have to special case it
5425              everywhere.  */
5426           set_nonincremental_init_from_string (value);
5427         }
5428     }
5429   else
5430     {
5431       warning_init ("braces around scalar initializer");
5432       constructor_fields = constructor_type;
5433       constructor_unfilled_fields = constructor_type;
5434     }
5435 }
5436
5437 /* At the end of an implicit or explicit brace level,
5438    finish up that level of constructor.
5439    If we were outputting the elements as they are read, return 0
5440    from inner levels (process_init_element ignores that),
5441    but return error_mark_node from the outermost level
5442    (that's what we want to put in DECL_INITIAL).
5443    Otherwise, return a CONSTRUCTOR expression.  */
5444
5445 tree
5446 pop_init_level (implicit)
5447      int implicit;
5448 {
5449   struct constructor_stack *p;
5450   tree constructor = 0;
5451
5452   if (implicit == 0)
5453     {
5454       /* When we come to an explicit close brace,
5455          pop any inner levels that didn't have explicit braces.  */
5456       while (constructor_stack->implicit)
5457         process_init_element (pop_init_level (1));
5458
5459       if (constructor_range_stack)
5460         abort ();
5461     }
5462
5463   p = constructor_stack;
5464
5465   /* Error for initializing a flexible array member, or a zero-length
5466      array member in an inappropriate context.  */
5467   if (constructor_type && constructor_fields
5468       && TREE_CODE (constructor_type) == ARRAY_TYPE
5469       && TYPE_DOMAIN (constructor_type)
5470       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5471     {
5472       /* Silently discard empty initializations.  The parser will
5473          already have pedwarned for empty brackets.  */
5474       if (integer_zerop (constructor_unfilled_index))
5475         constructor_type = NULL_TREE;
5476       else if (! TYPE_SIZE (constructor_type))
5477         {
5478           if (constructor_depth > 2)
5479             error_init ("initialization of flexible array member in a nested context");
5480           else if (pedantic)
5481             pedwarn_init ("initialization of a flexible array member");
5482
5483           /* We have already issued an error message for the existence
5484              of a flexible array member not at the end of the structure.
5485              Discard the initializer so that we do not abort later.  */
5486           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5487             constructor_type = NULL_TREE;
5488         }
5489       else
5490         /* Zero-length arrays are no longer special, so we should no longer
5491            get here.  */
5492         abort ();
5493     }
5494
5495   /* Warn when some struct elements are implicitly initialized to zero.  */
5496   if (extra_warnings
5497       && constructor_type
5498       && TREE_CODE (constructor_type) == RECORD_TYPE
5499       && constructor_unfilled_fields)
5500     {
5501         /* Do not warn for flexible array members or zero-length arrays.  */
5502         while (constructor_unfilled_fields
5503                && (! DECL_SIZE (constructor_unfilled_fields)
5504                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5505           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5506
5507         /* Do not warn if this level of the initializer uses member
5508            designators; it is likely to be deliberate.  */
5509         if (constructor_unfilled_fields && !constructor_designated)
5510           {
5511             push_member_name (constructor_unfilled_fields);
5512             warning_init ("missing initializer");
5513             RESTORE_SPELLING_DEPTH (constructor_depth);
5514           }
5515     }
5516
5517   /* Now output all pending elements.  */
5518   constructor_incremental = 1;
5519   output_pending_init_elements (1);
5520
5521   /* Pad out the end of the structure.  */
5522   if (p->replacement_value)
5523     /* If this closes a superfluous brace pair,
5524        just pass out the element between them.  */
5525     constructor = p->replacement_value;
5526   else if (constructor_type == 0)
5527     ;
5528   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5529            && TREE_CODE (constructor_type) != UNION_TYPE
5530            && TREE_CODE (constructor_type) != ARRAY_TYPE
5531            && TREE_CODE (constructor_type) != VECTOR_TYPE)
5532     {
5533       /* A nonincremental scalar initializer--just return
5534          the element, after verifying there is just one.  */
5535       if (constructor_elements == 0)
5536         {
5537           if (!constructor_erroneous)
5538             error_init ("empty scalar initializer");
5539           constructor = error_mark_node;
5540         }
5541       else if (TREE_CHAIN (constructor_elements) != 0)
5542         {
5543           error_init ("extra elements in scalar initializer");
5544           constructor = TREE_VALUE (constructor_elements);
5545         }
5546       else
5547         constructor = TREE_VALUE (constructor_elements);
5548     }
5549   else
5550     {
5551       if (constructor_erroneous)
5552         constructor = error_mark_node;
5553       else
5554         {
5555           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5556                                nreverse (constructor_elements));
5557           if (constructor_constant)
5558             TREE_CONSTANT (constructor) = 1;
5559           if (constructor_constant && constructor_simple)
5560             TREE_STATIC (constructor) = 1;
5561         }
5562     }
5563
5564   constructor_type = p->type;
5565   constructor_fields = p->fields;
5566   constructor_index = p->index;
5567   constructor_max_index = p->max_index;
5568   constructor_unfilled_index = p->unfilled_index;
5569   constructor_unfilled_fields = p->unfilled_fields;
5570   constructor_bit_index = p->bit_index;
5571   constructor_elements = p->elements;
5572   constructor_constant = p->constant;
5573   constructor_simple = p->simple;
5574   constructor_erroneous = p->erroneous;
5575   constructor_incremental = p->incremental;
5576   constructor_designated = p->designated;
5577   constructor_pending_elts = p->pending_elts;
5578   constructor_depth = p->depth;
5579   if (!p->implicit)
5580     constructor_range_stack = p->range_stack;
5581   RESTORE_SPELLING_DEPTH (constructor_depth);
5582
5583   constructor_stack = p->next;
5584   free (p);
5585
5586   if (constructor == 0)
5587     {
5588       if (constructor_stack == 0)
5589         return error_mark_node;
5590       return NULL_TREE;
5591     }
5592   return constructor;
5593 }
5594
5595 /* Common handling for both array range and field name designators.
5596    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
5597
5598 static int
5599 set_designator (array)
5600      int array;
5601 {
5602   tree subtype;
5603   enum tree_code subcode;
5604
5605   /* Don't die if an entire brace-pair level is superfluous
5606      in the containing level.  */
5607   if (constructor_type == 0)
5608     return 1;
5609
5610   /* If there were errors in this designator list already, bail out silently.  */
5611   if (designator_errorneous)
5612     return 1;
5613
5614   if (!designator_depth)
5615     {
5616       if (constructor_range_stack)
5617         abort ();
5618
5619       /* Designator list starts at the level of closest explicit
5620          braces.  */
5621       while (constructor_stack->implicit)
5622         process_init_element (pop_init_level (1));
5623       constructor_designated = 1;
5624       return 0;
5625     }
5626
5627   if (constructor_no_implicit)
5628     {
5629       error_init ("initialization designators may not nest");
5630       return 1;
5631     }
5632
5633   if (TREE_CODE (constructor_type) == RECORD_TYPE
5634       || TREE_CODE (constructor_type) == UNION_TYPE)
5635     {
5636       subtype = TREE_TYPE (constructor_fields);
5637       if (subtype != error_mark_node)
5638         subtype = TYPE_MAIN_VARIANT (subtype);
5639     }
5640   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5641     {
5642       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5643     }
5644   else
5645     abort ();
5646
5647   subcode = TREE_CODE (subtype);
5648   if (array && subcode != ARRAY_TYPE)
5649     {
5650       error_init ("array index in non-array initializer");
5651       return 1;
5652     }
5653   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5654     {
5655       error_init ("field name not in record or union initializer");
5656       return 1;
5657     }
5658
5659   constructor_designated = 1;
5660   push_init_level (2);
5661   return 0;
5662 }
5663
5664 /* If there are range designators in designator list, push a new designator
5665    to constructor_range_stack.  RANGE_END is end of such stack range or
5666    NULL_TREE if there is no range designator at this level.  */
5667
5668 static void
5669 push_range_stack (range_end)
5670      tree range_end;
5671 {
5672   struct constructor_range_stack *p;
5673
5674   p = (struct constructor_range_stack *)
5675       ggc_alloc (sizeof (struct constructor_range_stack));
5676   p->prev = constructor_range_stack;
5677   p->next = 0;
5678   p->fields = constructor_fields;
5679   p->range_start = constructor_index;
5680   p->index = constructor_index;
5681   p->stack = constructor_stack;
5682   p->range_end = range_end;
5683   if (constructor_range_stack)
5684     constructor_range_stack->next = p;
5685   constructor_range_stack = p;
5686 }
5687
5688 /* Within an array initializer, specify the next index to be initialized.
5689    FIRST is that index.  If LAST is nonzero, then initialize a range
5690    of indices, running from FIRST through LAST.  */
5691
5692 void
5693 set_init_index (first, last)
5694      tree first, last;
5695 {
5696   if (set_designator (1))
5697     return;
5698
5699   designator_errorneous = 1;
5700
5701   while ((TREE_CODE (first) == NOP_EXPR
5702           || TREE_CODE (first) == CONVERT_EXPR
5703           || TREE_CODE (first) == NON_LVALUE_EXPR)
5704          && (TYPE_MODE (TREE_TYPE (first))
5705              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5706     first = TREE_OPERAND (first, 0);
5707
5708   if (last)
5709     while ((TREE_CODE (last) == NOP_EXPR
5710             || TREE_CODE (last) == CONVERT_EXPR
5711             || TREE_CODE (last) == NON_LVALUE_EXPR)
5712            && (TYPE_MODE (TREE_TYPE (last))
5713                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5714       last = TREE_OPERAND (last, 0);
5715
5716   if (TREE_CODE (first) != INTEGER_CST)
5717     error_init ("nonconstant array index in initializer");
5718   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5719     error_init ("nonconstant array index in initializer");
5720   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5721     error_init ("array index in non-array initializer");
5722   else if (constructor_max_index
5723            && tree_int_cst_lt (constructor_max_index, first))
5724     error_init ("array index in initializer exceeds array bounds");
5725   else
5726     {
5727       constructor_index = convert (bitsizetype, first);
5728
5729       if (last)
5730         {
5731           if (tree_int_cst_equal (first, last))
5732             last = 0;
5733           else if (tree_int_cst_lt (last, first))
5734             {
5735               error_init ("empty index range in initializer");
5736               last = 0;
5737             }
5738           else
5739             {
5740               last = convert (bitsizetype, last);
5741               if (constructor_max_index != 0
5742                   && tree_int_cst_lt (constructor_max_index, last))
5743                 {
5744                   error_init ("array index range in initializer exceeds array bounds");
5745                   last = 0;
5746                 }
5747             }
5748         }
5749
5750       designator_depth++;
5751       designator_errorneous = 0;
5752       if (constructor_range_stack || last)
5753         push_range_stack (last);
5754     }
5755 }
5756
5757 /* Within a struct initializer, specify the next field to be initialized.  */
5758
5759 void
5760 set_init_label (fieldname)
5761      tree fieldname;
5762 {
5763   tree tail;
5764
5765   if (set_designator (0))
5766     return;
5767
5768   designator_errorneous = 1;
5769
5770   if (TREE_CODE (constructor_type) != RECORD_TYPE
5771       && TREE_CODE (constructor_type) != UNION_TYPE)
5772     {
5773       error_init ("field name not in record or union initializer");
5774       return;
5775     }
5776
5777   for (tail = TYPE_FIELDS (constructor_type); tail;
5778        tail = TREE_CHAIN (tail))
5779     {
5780       if (DECL_NAME (tail) == fieldname)
5781         break;
5782     }
5783
5784   if (tail == 0)
5785     error ("unknown field `%s' specified in initializer",
5786            IDENTIFIER_POINTER (fieldname));
5787   else
5788     {
5789       constructor_fields = tail;
5790       designator_depth++;
5791       designator_errorneous = 0;
5792       if (constructor_range_stack)
5793         push_range_stack (NULL_TREE);
5794     }
5795 }
5796 \f
5797 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5798    identifies the initializer, either array index or field in a structure.
5799    VALUE is the value of that index or field.  */
5800
5801 static void
5802 add_pending_init (purpose, value)
5803      tree purpose, value;
5804 {
5805   struct init_node *p, **q, *r;
5806
5807   q = &constructor_pending_elts;
5808   p = 0;
5809
5810   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5811     {
5812       while (*q != 0)
5813         {
5814           p = *q;
5815           if (tree_int_cst_lt (purpose, p->purpose))
5816             q = &p->left;
5817           else if (tree_int_cst_lt (p->purpose, purpose))
5818             q = &p->right;
5819           else
5820             {
5821               if (TREE_SIDE_EFFECTS (p->value))
5822                 warning_init ("initialized field with side-effects overwritten");
5823               p->value = value;
5824               return;
5825             }
5826         }
5827     }
5828   else
5829     {
5830       tree bitpos;
5831
5832       bitpos = bit_position (purpose);
5833       while (*q != NULL)
5834         {
5835           p = *q;
5836           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5837             q = &p->left;
5838           else if (p->purpose != purpose)
5839             q = &p->right;
5840           else
5841             {
5842               if (TREE_SIDE_EFFECTS (p->value))
5843                 warning_init ("initialized field with side-effects overwritten");
5844               p->value = value;
5845               return;
5846             }
5847         }
5848     }
5849
5850   r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5851   r->purpose = purpose;
5852   r->value = value;
5853
5854   *q = r;
5855   r->parent = p;
5856   r->left = 0;
5857   r->right = 0;
5858   r->balance = 0;
5859
5860   while (p)
5861     {
5862       struct init_node *s;
5863
5864       if (r == p->left)
5865         {
5866           if (p->balance == 0)
5867             p->balance = -1;
5868           else if (p->balance < 0)
5869             {
5870               if (r->balance < 0)
5871                 {
5872                   /* L rotation.  */
5873                   p->left = r->right;
5874                   if (p->left)
5875                     p->left->parent = p;
5876                   r->right = p;
5877
5878                   p->balance = 0;
5879                   r->balance = 0;
5880
5881                   s = p->parent;
5882                   p->parent = r;
5883                   r->parent = s;
5884                   if (s)
5885                     {
5886                       if (s->left == p)
5887                         s->left = r;
5888                       else
5889                         s->right = r;
5890                     }
5891                   else
5892                     constructor_pending_elts = r;
5893                 }
5894               else
5895                 {
5896                   /* LR rotation.  */
5897                   struct init_node *t = r->right;
5898
5899                   r->right = t->left;
5900                   if (r->right)
5901                     r->right->parent = r;
5902                   t->left = r;
5903
5904                   p->left = t->right;
5905                   if (p->left)
5906                     p->left->parent = p;
5907                   t->right = p;
5908
5909                   p->balance = t->balance < 0;
5910                   r->balance = -(t->balance > 0);
5911                   t->balance = 0;
5912
5913                   s = p->parent;
5914                   p->parent = t;
5915                   r->parent = t;
5916                   t->parent = s;
5917                   if (s)
5918                     {
5919                       if (s->left == p)
5920                         s->left = t;
5921                       else
5922                         s->right = t;
5923                     }
5924                   else
5925                     constructor_pending_elts = t;
5926                 }
5927               break;
5928             }
5929           else
5930             {
5931               /* p->balance == +1; growth of left side balances the node.  */
5932               p->balance = 0;
5933               break;
5934             }
5935         }
5936       else /* r == p->right */
5937         {
5938           if (p->balance == 0)
5939             /* Growth propagation from right side.  */
5940             p->balance++;
5941           else if (p->balance > 0)
5942             {
5943               if (r->balance > 0)
5944                 {
5945                   /* R rotation.  */
5946                   p->right = r->left;
5947                   if (p->right)
5948                     p->right->parent = p;
5949                   r->left = p;
5950
5951                   p->balance = 0;
5952                   r->balance = 0;
5953
5954                   s = p->parent;
5955                   p->parent = r;
5956                   r->parent = s;
5957                   if (s)
5958                     {
5959                       if (s->left == p)
5960                         s->left = r;
5961                       else
5962                         s->right = r;
5963                     }
5964                   else
5965                     constructor_pending_elts = r;
5966                 }
5967               else /* r->balance == -1 */
5968                 {
5969                   /* RL rotation */
5970                   struct init_node *t = r->left;
5971
5972                   r->left = t->right;
5973                   if (r->left)
5974                     r->left->parent = r;
5975                   t->right = r;
5976
5977                   p->right = t->left;
5978                   if (p->right)
5979                     p->right->parent = p;
5980                   t->left = p;
5981
5982                   r->balance = (t->balance < 0);
5983                   p->balance = -(t->balance > 0);
5984                   t->balance = 0;
5985
5986                   s = p->parent;
5987                   p->parent = t;
5988                   r->parent = t;
5989                   t->parent = s;
5990                   if (s)
5991                     {
5992                       if (s->left == p)
5993                         s->left = t;
5994                       else
5995                         s->right = t;
5996                     }
5997                   else
5998                     constructor_pending_elts = t;
5999                 }
6000               break;
6001             }
6002           else
6003             {
6004               /* p->balance == -1; growth of right side balances the node.  */
6005               p->balance = 0;
6006               break;
6007             }
6008         }
6009
6010       r = p;
6011       p = p->parent;
6012     }
6013 }
6014
6015 /* Build AVL tree from a sorted chain.  */
6016
6017 static void
6018 set_nonincremental_init ()
6019 {
6020   tree chain;
6021
6022   if (TREE_CODE (constructor_type) != RECORD_TYPE
6023       && TREE_CODE (constructor_type) != ARRAY_TYPE)
6024     return;
6025
6026   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
6027     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
6028   constructor_elements = 0;
6029   if (TREE_CODE (constructor_type) == RECORD_TYPE)
6030     {
6031       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
6032       /* Skip any nameless bit fields at the beginning.  */
6033       while (constructor_unfilled_fields != 0
6034              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6035              && DECL_NAME (constructor_unfilled_fields) == 0)
6036         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6037
6038     }
6039   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6040     {
6041       if (TYPE_DOMAIN (constructor_type))
6042         constructor_unfilled_index
6043             = convert (bitsizetype,
6044                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6045       else
6046         constructor_unfilled_index = bitsize_zero_node;
6047     }
6048   constructor_incremental = 0;
6049 }
6050
6051 /* Build AVL tree from a string constant.  */
6052
6053 static void
6054 set_nonincremental_init_from_string (str)
6055      tree str;
6056 {
6057   tree value, purpose, type;
6058   HOST_WIDE_INT val[2];
6059   const char *p, *end;
6060   int byte, wchar_bytes, charwidth, bitpos;
6061
6062   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6063     abort ();
6064
6065   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6066       == TYPE_PRECISION (char_type_node))
6067     wchar_bytes = 1;
6068   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6069            == TYPE_PRECISION (wchar_type_node))
6070     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6071   else
6072     abort ();
6073
6074   charwidth = TYPE_PRECISION (char_type_node);
6075   type = TREE_TYPE (constructor_type);
6076   p = TREE_STRING_POINTER (str);
6077   end = p + TREE_STRING_LENGTH (str);
6078
6079   for (purpose = bitsize_zero_node;
6080        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6081        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6082     {
6083       if (wchar_bytes == 1)
6084         {
6085           val[1] = (unsigned char) *p++;
6086           val[0] = 0;
6087         }
6088       else
6089         {
6090           val[0] = 0;
6091           val[1] = 0;
6092           for (byte = 0; byte < wchar_bytes; byte++)
6093             {
6094               if (BYTES_BIG_ENDIAN)
6095                 bitpos = (wchar_bytes - byte - 1) * charwidth;
6096               else
6097                 bitpos = byte * charwidth;
6098               val[bitpos < HOST_BITS_PER_WIDE_INT]
6099                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6100                    << (bitpos % HOST_BITS_PER_WIDE_INT);
6101             }
6102         }
6103
6104       if (!TREE_UNSIGNED (type))
6105         {
6106           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6107           if (bitpos < HOST_BITS_PER_WIDE_INT)
6108             {
6109               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6110                 {
6111                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6112                   val[0] = -1;
6113                 }
6114             }
6115           else if (bitpos == HOST_BITS_PER_WIDE_INT)
6116             {
6117               if (val[1] < 0)
6118                 val[0] = -1;
6119             }
6120           else if (val[0] & (((HOST_WIDE_INT) 1)
6121                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6122             val[0] |= ((HOST_WIDE_INT) -1)
6123                       << (bitpos - HOST_BITS_PER_WIDE_INT);
6124         }
6125
6126       value = build_int_2 (val[1], val[0]);
6127       TREE_TYPE (value) = type;
6128       add_pending_init (purpose, value);
6129     }
6130
6131   constructor_incremental = 0;
6132 }
6133
6134 /* Return value of FIELD in pending initializer or zero if the field was
6135    not initialized yet.  */
6136
6137 static tree
6138 find_init_member (field)
6139      tree field;
6140 {
6141   struct init_node *p;
6142
6143   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6144     {
6145       if (constructor_incremental
6146           && tree_int_cst_lt (field, constructor_unfilled_index))
6147         set_nonincremental_init ();
6148
6149       p = constructor_pending_elts;
6150       while (p)
6151         {
6152           if (tree_int_cst_lt (field, p->purpose))
6153             p = p->left;
6154           else if (tree_int_cst_lt (p->purpose, field))
6155             p = p->right;
6156           else
6157             return p->value;
6158         }
6159     }
6160   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6161     {
6162       tree bitpos = bit_position (field);
6163
6164       if (constructor_incremental
6165           && (!constructor_unfilled_fields
6166               || tree_int_cst_lt (bitpos,
6167                                   bit_position (constructor_unfilled_fields))))
6168         set_nonincremental_init ();
6169
6170       p = constructor_pending_elts;
6171       while (p)
6172         {
6173           if (field == p->purpose)
6174             return p->value;
6175           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6176             p = p->left;
6177           else
6178             p = p->right;
6179         }
6180     }
6181   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6182     {
6183       if (constructor_elements
6184           && TREE_PURPOSE (constructor_elements) == field)
6185         return TREE_VALUE (constructor_elements);
6186     }
6187   return 0;
6188 }
6189
6190 /* "Output" the next constructor element.
6191    At top level, really output it to assembler code now.
6192    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6193    TYPE is the data type that the containing data type wants here.
6194    FIELD is the field (a FIELD_DECL) or the index that this element fills.
6195
6196    PENDING if non-nil means output pending elements that belong
6197    right after this element.  (PENDING is normally 1;
6198    it is 0 while outputting pending elements, to avoid recursion.)  */
6199
6200 static void
6201 output_init_element (value, type, field, pending)
6202      tree value, type, field;
6203      int pending;
6204 {
6205   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6206       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6207           && !(TREE_CODE (value) == STRING_CST
6208                && TREE_CODE (type) == ARRAY_TYPE
6209                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6210           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6211                          TYPE_MAIN_VARIANT (type))))
6212     value = default_conversion (value);
6213
6214   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
6215       && require_constant_value && !flag_isoc99 && pending)
6216     {
6217       /* As an extension, allow initializing objects with static storage
6218          duration with compound literals (which are then treated just as
6219          the brace enclosed list they contain).  */
6220       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
6221       value = DECL_INITIAL (decl);
6222     }
6223
6224   if (value == error_mark_node)
6225     constructor_erroneous = 1;
6226   else if (!TREE_CONSTANT (value))
6227     constructor_constant = 0;
6228   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6229            || ((TREE_CODE (constructor_type) == RECORD_TYPE
6230                 || TREE_CODE (constructor_type) == UNION_TYPE)
6231                && DECL_C_BIT_FIELD (field)
6232                && TREE_CODE (value) != INTEGER_CST))
6233     constructor_simple = 0;
6234
6235   if (require_constant_value && ! TREE_CONSTANT (value))
6236     {
6237       error_init ("initializer element is not constant");
6238       value = error_mark_node;
6239     }
6240   else if (require_constant_elements
6241            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6242     pedwarn ("initializer element is not computable at load time");
6243
6244   /* If this field is empty (and not at the end of structure),
6245      don't do anything other than checking the initializer.  */
6246   if (field
6247       && (TREE_TYPE (field) == error_mark_node
6248           || (COMPLETE_TYPE_P (TREE_TYPE (field))
6249               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6250               && (TREE_CODE (constructor_type) == ARRAY_TYPE
6251                   || TREE_CHAIN (field)))))
6252     return;
6253
6254   value = digest_init (type, value, require_constant_value);
6255   if (value == error_mark_node)
6256     {
6257       constructor_erroneous = 1;
6258       return;
6259     }
6260
6261   /* If this element doesn't come next in sequence,
6262      put it on constructor_pending_elts.  */
6263   if (TREE_CODE (constructor_type) == ARRAY_TYPE
6264       && (!constructor_incremental
6265           || !tree_int_cst_equal (field, constructor_unfilled_index)))
6266     {
6267       if (constructor_incremental
6268           && tree_int_cst_lt (field, constructor_unfilled_index))
6269         set_nonincremental_init ();
6270
6271       add_pending_init (field, value);
6272       return;
6273     }
6274   else if (TREE_CODE (constructor_type) == RECORD_TYPE
6275            && (!constructor_incremental
6276                || field != constructor_unfilled_fields))
6277     {
6278       /* We do this for records but not for unions.  In a union,
6279          no matter which field is specified, it can be initialized
6280          right away since it starts at the beginning of the union.  */
6281       if (constructor_incremental)
6282         {
6283           if (!constructor_unfilled_fields)
6284             set_nonincremental_init ();
6285           else
6286             {
6287               tree bitpos, unfillpos;
6288
6289               bitpos = bit_position (field);
6290               unfillpos = bit_position (constructor_unfilled_fields);
6291
6292               if (tree_int_cst_lt (bitpos, unfillpos))
6293                 set_nonincremental_init ();
6294             }
6295         }
6296
6297       add_pending_init (field, value);
6298       return;
6299     }
6300   else if (TREE_CODE (constructor_type) == UNION_TYPE
6301            && constructor_elements)
6302     {
6303       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6304         warning_init ("initialized field with side-effects overwritten");
6305
6306       /* We can have just one union field set.  */
6307       constructor_elements = 0;
6308     }
6309
6310   /* Otherwise, output this element either to
6311      constructor_elements or to the assembler file.  */
6312
6313   if (field && TREE_CODE (field) == INTEGER_CST)
6314     field = copy_node (field);
6315   constructor_elements
6316     = tree_cons (field, value, constructor_elements);
6317
6318   /* Advance the variable that indicates sequential elements output.  */
6319   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6320     constructor_unfilled_index
6321       = size_binop (PLUS_EXPR, constructor_unfilled_index,
6322                     bitsize_one_node);
6323   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6324     {
6325       constructor_unfilled_fields
6326         = TREE_CHAIN (constructor_unfilled_fields);
6327
6328       /* Skip any nameless bit fields.  */
6329       while (constructor_unfilled_fields != 0
6330              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6331              && DECL_NAME (constructor_unfilled_fields) == 0)
6332         constructor_unfilled_fields =
6333           TREE_CHAIN (constructor_unfilled_fields);
6334     }
6335   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6336     constructor_unfilled_fields = 0;
6337
6338   /* Now output any pending elements which have become next.  */
6339   if (pending)
6340     output_pending_init_elements (0);
6341 }
6342
6343 /* Output any pending elements which have become next.
6344    As we output elements, constructor_unfilled_{fields,index}
6345    advances, which may cause other elements to become next;
6346    if so, they too are output.
6347
6348    If ALL is 0, we return when there are
6349    no more pending elements to output now.
6350
6351    If ALL is 1, we output space as necessary so that
6352    we can output all the pending elements.  */
6353
6354 static void
6355 output_pending_init_elements (all)
6356      int all;
6357 {
6358   struct init_node *elt = constructor_pending_elts;
6359   tree next;
6360
6361  retry:
6362
6363   /* Look thru the whole pending tree.
6364      If we find an element that should be output now,
6365      output it.  Otherwise, set NEXT to the element
6366      that comes first among those still pending.  */
6367
6368   next = 0;
6369   while (elt)
6370     {
6371       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6372         {
6373           if (tree_int_cst_equal (elt->purpose,
6374                                   constructor_unfilled_index))
6375             output_init_element (elt->value,
6376                                  TREE_TYPE (constructor_type),
6377                                  constructor_unfilled_index, 0);
6378           else if (tree_int_cst_lt (constructor_unfilled_index,
6379                                     elt->purpose))
6380             {
6381               /* Advance to the next smaller node.  */
6382               if (elt->left)
6383                 elt = elt->left;
6384               else
6385                 {
6386                   /* We have reached the smallest node bigger than the
6387                      current unfilled index.  Fill the space first.  */
6388                   next = elt->purpose;
6389                   break;
6390                 }
6391             }
6392           else
6393             {
6394               /* Advance to the next bigger node.  */
6395               if (elt->right)
6396                 elt = elt->right;
6397               else
6398                 {
6399                   /* We have reached the biggest node in a subtree.  Find
6400                      the parent of it, which is the next bigger node.  */
6401                   while (elt->parent && elt->parent->right == elt)
6402                     elt = elt->parent;
6403                   elt = elt->parent;
6404                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6405                                               elt->purpose))
6406                     {
6407                       next = elt->purpose;
6408                       break;
6409                     }
6410                 }
6411             }
6412         }
6413       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6414                || TREE_CODE (constructor_type) == UNION_TYPE)
6415         {
6416           tree ctor_unfilled_bitpos, elt_bitpos;
6417
6418           /* If the current record is complete we are done.  */
6419           if (constructor_unfilled_fields == 0)
6420             break;
6421
6422           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6423           elt_bitpos = bit_position (elt->purpose);
6424           /* We can't compare fields here because there might be empty
6425              fields in between.  */
6426           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6427             {
6428               constructor_unfilled_fields = elt->purpose;
6429               output_init_element (elt->value, TREE_TYPE (elt->purpose),
6430                                    elt->purpose, 0);
6431             }
6432           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6433             {
6434               /* Advance to the next smaller node.  */
6435               if (elt->left)
6436                 elt = elt->left;
6437               else
6438                 {
6439                   /* We have reached the smallest node bigger than the
6440                      current unfilled field.  Fill the space first.  */
6441                   next = elt->purpose;
6442                   break;
6443                 }
6444             }
6445           else
6446             {
6447               /* Advance to the next bigger node.  */
6448               if (elt->right)
6449                 elt = elt->right;
6450               else
6451                 {
6452                   /* We have reached the biggest node in a subtree.  Find
6453                      the parent of it, which is the next bigger node.  */
6454                   while (elt->parent && elt->parent->right == elt)
6455                     elt = elt->parent;
6456                   elt = elt->parent;
6457                   if (elt
6458                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
6459                                            bit_position (elt->purpose))))
6460                     {
6461                       next = elt->purpose;
6462                       break;
6463                     }
6464                 }
6465             }
6466         }
6467     }
6468
6469   /* Ordinarily return, but not if we want to output all
6470      and there are elements left.  */
6471   if (! (all && next != 0))
6472     return;
6473
6474   /* If it's not incremental, just skip over the gap, so that after
6475      jumping to retry we will output the next successive element.  */
6476   if (TREE_CODE (constructor_type) == RECORD_TYPE
6477       || TREE_CODE (constructor_type) == UNION_TYPE)
6478     constructor_unfilled_fields = next;
6479   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6480     constructor_unfilled_index = next;
6481
6482   /* ELT now points to the node in the pending tree with the next
6483      initializer to output.  */
6484   goto retry;
6485 }
6486 \f
6487 /* Add one non-braced element to the current constructor level.
6488    This adjusts the current position within the constructor's type.
6489    This may also start or terminate implicit levels
6490    to handle a partly-braced initializer.
6491
6492    Once this has found the correct level for the new element,
6493    it calls output_init_element.  */
6494
6495 void
6496 process_init_element (value)
6497      tree value;
6498 {
6499   tree orig_value = value;
6500   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6501
6502   designator_depth = 0;
6503   designator_errorneous = 0;
6504
6505   /* Handle superfluous braces around string cst as in
6506      char x[] = {"foo"}; */
6507   if (string_flag
6508       && constructor_type
6509       && TREE_CODE (constructor_type) == ARRAY_TYPE
6510       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6511       && integer_zerop (constructor_unfilled_index))
6512     {
6513       if (constructor_stack->replacement_value)
6514         error_init ("excess elements in char array initializer");
6515       constructor_stack->replacement_value = value;
6516       return;
6517     }
6518
6519   if (constructor_stack->replacement_value != 0)
6520     {
6521       error_init ("excess elements in struct initializer");
6522       return;
6523     }
6524
6525   /* Ignore elements of a brace group if it is entirely superfluous
6526      and has already been diagnosed.  */
6527   if (constructor_type == 0)
6528     return;
6529
6530   /* If we've exhausted any levels that didn't have braces,
6531      pop them now.  */
6532   while (constructor_stack->implicit)
6533     {
6534       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6535            || TREE_CODE (constructor_type) == UNION_TYPE)
6536           && constructor_fields == 0)
6537         process_init_element (pop_init_level (1));
6538       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6539                && (constructor_max_index == 0
6540                    || tree_int_cst_lt (constructor_max_index,
6541                                        constructor_index)))
6542         process_init_element (pop_init_level (1));
6543       else
6544         break;
6545     }
6546
6547   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
6548   if (constructor_range_stack)
6549     {
6550       /* If value is a compound literal and we'll be just using its
6551          content, don't put it into a SAVE_EXPR.  */
6552       if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
6553           || !require_constant_value
6554           || flag_isoc99)
6555         value = save_expr (value);
6556     }
6557
6558   while (1)
6559     {
6560       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6561         {
6562           tree fieldtype;
6563           enum tree_code fieldcode;
6564
6565           if (constructor_fields == 0)
6566             {
6567               pedwarn_init ("excess elements in struct initializer");
6568               break;
6569             }
6570
6571           fieldtype = TREE_TYPE (constructor_fields);
6572           if (fieldtype != error_mark_node)
6573             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6574           fieldcode = TREE_CODE (fieldtype);
6575
6576           /* Error for non-static initialization of a flexible array member.  */
6577           if (fieldcode == ARRAY_TYPE
6578               && !require_constant_value
6579               && TYPE_SIZE (fieldtype) == NULL_TREE
6580               && TREE_CHAIN (constructor_fields) == NULL_TREE)
6581             {
6582               error_init ("non-static initialization of a flexible array member");
6583               break;
6584             }
6585
6586           /* Accept a string constant to initialize a subarray.  */
6587           if (value != 0
6588               && fieldcode == ARRAY_TYPE
6589               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6590               && string_flag)
6591             value = orig_value;
6592           /* Otherwise, if we have come to a subaggregate,
6593              and we don't have an element of its type, push into it.  */
6594           else if (value != 0 && !constructor_no_implicit
6595                    && value != error_mark_node
6596                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6597                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6598                        || fieldcode == UNION_TYPE))
6599             {
6600               push_init_level (1);
6601               continue;
6602             }
6603
6604           if (value)
6605             {
6606               push_member_name (constructor_fields);
6607               output_init_element (value, fieldtype, constructor_fields, 1);
6608               RESTORE_SPELLING_DEPTH (constructor_depth);
6609             }
6610           else
6611             /* Do the bookkeeping for an element that was
6612                directly output as a constructor.  */
6613             {
6614               /* For a record, keep track of end position of last field.  */
6615               if (DECL_SIZE (constructor_fields))
6616                 constructor_bit_index
6617                   = size_binop (PLUS_EXPR,
6618                                 bit_position (constructor_fields),
6619                                 DECL_SIZE (constructor_fields));
6620
6621               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6622               /* Skip any nameless bit fields.  */
6623               while (constructor_unfilled_fields != 0
6624                      && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6625                      && DECL_NAME (constructor_unfilled_fields) == 0)
6626                 constructor_unfilled_fields =
6627                   TREE_CHAIN (constructor_unfilled_fields);
6628             }
6629
6630           constructor_fields = TREE_CHAIN (constructor_fields);
6631           /* Skip any nameless bit fields at the beginning.  */
6632           while (constructor_fields != 0
6633                  && DECL_C_BIT_FIELD (constructor_fields)
6634                  && DECL_NAME (constructor_fields) == 0)
6635             constructor_fields = TREE_CHAIN (constructor_fields);
6636         }
6637       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6638         {
6639           tree fieldtype;
6640           enum tree_code fieldcode;
6641
6642           if (constructor_fields == 0)
6643             {
6644               pedwarn_init ("excess elements in union initializer");
6645               break;
6646             }
6647
6648           fieldtype = TREE_TYPE (constructor_fields);
6649           if (fieldtype != error_mark_node)
6650             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6651           fieldcode = TREE_CODE (fieldtype);
6652
6653           /* Warn that traditional C rejects initialization of unions.
6654              We skip the warning if the value is zero.  This is done
6655              under the assumption that the zero initializer in user
6656              code appears conditioned on e.g. __STDC__ to avoid
6657              "missing initializer" warnings and relies on default
6658              initialization to zero in the traditional C case.
6659              We also skip the warning if the initializer is designated,
6660              again on the assumption that this must be conditional on
6661              __STDC__ anyway (and we've already complained about the
6662              member-designator already).  */
6663           if (warn_traditional && !in_system_header && !constructor_designated
6664               && !(value && (integer_zerop (value) || real_zerop (value))))
6665             warning ("traditional C rejects initialization of unions");
6666
6667           /* Accept a string constant to initialize a subarray.  */
6668           if (value != 0
6669               && fieldcode == ARRAY_TYPE
6670               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6671               && string_flag)
6672             value = orig_value;
6673           /* Otherwise, if we have come to a subaggregate,
6674              and we don't have an element of its type, push into it.  */
6675           else if (value != 0 && !constructor_no_implicit
6676                    && value != error_mark_node
6677                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6678                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6679                        || fieldcode == UNION_TYPE))
6680             {
6681               push_init_level (1);
6682               continue;
6683             }
6684
6685           if (value)
6686             {
6687               push_member_name (constructor_fields);
6688               output_init_element (value, fieldtype, constructor_fields, 1);
6689               RESTORE_SPELLING_DEPTH (constructor_depth);
6690             }
6691           else
6692             /* Do the bookkeeping for an element that was
6693                directly output as a constructor.  */
6694             {
6695               constructor_bit_index = DECL_SIZE (constructor_fields);
6696               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6697             }
6698
6699           constructor_fields = 0;
6700         }
6701       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6702         {
6703           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6704           enum tree_code eltcode = TREE_CODE (elttype);
6705
6706           /* Accept a string constant to initialize a subarray.  */
6707           if (value != 0
6708               && eltcode == ARRAY_TYPE
6709               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6710               && string_flag)
6711             value = orig_value;
6712           /* Otherwise, if we have come to a subaggregate,
6713              and we don't have an element of its type, push into it.  */
6714           else if (value != 0 && !constructor_no_implicit
6715                    && value != error_mark_node
6716                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6717                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6718                        || eltcode == UNION_TYPE))
6719             {
6720               push_init_level (1);
6721               continue;
6722             }
6723
6724           if (constructor_max_index != 0
6725               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6726                   || integer_all_onesp (constructor_max_index)))
6727             {
6728               pedwarn_init ("excess elements in array initializer");
6729               break;
6730             }
6731
6732           /* Now output the actual element.  */
6733           if (value)
6734             {
6735               push_array_bounds (tree_low_cst (constructor_index, 0));
6736               output_init_element (value, elttype, constructor_index, 1);
6737               RESTORE_SPELLING_DEPTH (constructor_depth);
6738             }
6739
6740           constructor_index
6741             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6742
6743           if (! value)
6744             /* If we are doing the bookkeeping for an element that was
6745                directly output as a constructor, we must update
6746                constructor_unfilled_index.  */
6747             constructor_unfilled_index = constructor_index;
6748         }
6749       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6750         {
6751           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6752
6753          /* Do a basic check of initializer size.  Note that vectors
6754             always have a fixed size derived from their type.  */
6755           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6756             {
6757               pedwarn_init ("excess elements in vector initializer");
6758               break;
6759             }
6760
6761           /* Now output the actual element.  */
6762           if (value)
6763             output_init_element (value, elttype, constructor_index, 1);
6764
6765           constructor_index
6766             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6767
6768           if (! value)
6769             /* If we are doing the bookkeeping for an element that was
6770                directly output as a constructor, we must update
6771                constructor_unfilled_index.  */
6772             constructor_unfilled_index = constructor_index;
6773         }
6774
6775       /* Handle the sole element allowed in a braced initializer
6776          for a scalar variable.  */
6777       else if (constructor_fields == 0)
6778         {
6779           pedwarn_init ("excess elements in scalar initializer");
6780           break;
6781         }
6782       else
6783         {
6784           if (value)
6785             output_init_element (value, constructor_type, NULL_TREE, 1);
6786           constructor_fields = 0;
6787         }
6788
6789       /* Handle range initializers either at this level or anywhere higher
6790          in the designator stack.  */
6791       if (constructor_range_stack)
6792         {
6793           struct constructor_range_stack *p, *range_stack;
6794           int finish = 0;
6795
6796           range_stack = constructor_range_stack;
6797           constructor_range_stack = 0;
6798           while (constructor_stack != range_stack->stack)
6799             {
6800               if (!constructor_stack->implicit)
6801                 abort ();
6802               process_init_element (pop_init_level (1));
6803             }
6804           for (p = range_stack;
6805                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6806                p = p->prev)
6807             {
6808               if (!constructor_stack->implicit)
6809                 abort ();
6810               process_init_element (pop_init_level (1));
6811             }
6812
6813           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6814           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6815             finish = 1;
6816
6817           while (1)
6818             {
6819               constructor_index = p->index;
6820               constructor_fields = p->fields;
6821               if (finish && p->range_end && p->index == p->range_start)
6822                 {
6823                   finish = 0;
6824                   p->prev = 0;
6825                 }
6826               p = p->next;
6827               if (!p)
6828                 break;
6829               push_init_level (2);
6830               p->stack = constructor_stack;
6831               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6832                 p->index = p->range_start;
6833             }
6834
6835           if (!finish)
6836             constructor_range_stack = range_stack;
6837           continue;
6838         }
6839
6840       break;
6841     }
6842
6843   constructor_range_stack = 0;
6844 }
6845 \f
6846 /* Build a simple asm-statement, from one string literal.  */
6847 tree
6848 simple_asm_stmt (expr)
6849      tree expr;
6850 {
6851   STRIP_NOPS (expr);
6852
6853   if (TREE_CODE (expr) == ADDR_EXPR)
6854     expr = TREE_OPERAND (expr, 0);
6855
6856   if (TREE_CODE (expr) == STRING_CST)
6857     {
6858       tree stmt;
6859
6860       stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6861                                    NULL_TREE, NULL_TREE,
6862                                    NULL_TREE));
6863       ASM_INPUT_P (stmt) = 1;
6864       return stmt;
6865     }
6866
6867   error ("argument of `asm' is not a constant string");
6868   return NULL_TREE;
6869 }
6870
6871 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6872    STRING, some OUTPUTS, some INPUTS, and some CLOBBERS.  */
6873
6874 tree
6875 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6876      tree cv_qualifier;
6877      tree string;
6878      tree outputs;
6879      tree inputs;
6880      tree clobbers;
6881 {
6882   tree tail;
6883
6884   if (TREE_CODE (string) != STRING_CST)
6885     {
6886       error ("asm template is not a string constant");
6887       return NULL_TREE;
6888     }
6889
6890   if (cv_qualifier != NULL_TREE
6891       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6892     {
6893       warning ("%s qualifier ignored on asm",
6894                IDENTIFIER_POINTER (cv_qualifier));
6895       cv_qualifier = NULL_TREE;
6896     }
6897
6898   /* We can remove output conversions that change the type,
6899      but not the mode.  */
6900   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6901     {
6902       tree output = TREE_VALUE (tail);
6903
6904       STRIP_NOPS (output);
6905       TREE_VALUE (tail) = output;
6906
6907       /* Allow conversions as LHS here.  build_modify_expr as called below
6908          will do the right thing with them.  */
6909       while (TREE_CODE (output) == NOP_EXPR
6910              || TREE_CODE (output) == CONVERT_EXPR
6911              || TREE_CODE (output) == FLOAT_EXPR
6912              || TREE_CODE (output) == FIX_TRUNC_EXPR
6913              || TREE_CODE (output) == FIX_FLOOR_EXPR
6914              || TREE_CODE (output) == FIX_ROUND_EXPR
6915              || TREE_CODE (output) == FIX_CEIL_EXPR)
6916         output = TREE_OPERAND (output, 0);
6917
6918       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6919     }
6920
6921   /* Remove output conversions that change the type but not the mode.  */
6922   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6923     {
6924       tree output = TREE_VALUE (tail);
6925       STRIP_NOPS (output);
6926       TREE_VALUE (tail) = output;
6927     }
6928
6929   /* Perform default conversions on array and function inputs.
6930      Don't do this for other types as it would screw up operands
6931      expected to be in memory.  */
6932   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6933     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6934
6935   return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6936                                outputs, inputs, clobbers));
6937 }
6938
6939 /* Expand an ASM statement with operands, handling output operands
6940    that are not variables or INDIRECT_REFS by transforming such
6941    cases into cases that expand_asm_operands can handle.
6942
6943    Arguments are same as for expand_asm_operands.  */
6944
6945 void
6946 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6947      tree string, outputs, inputs, clobbers;
6948      int vol;
6949      const char *filename;
6950      int line;
6951 {
6952   int noutputs = list_length (outputs);
6953   int i;
6954   /* o[I] is the place that output number I should be written.  */
6955   tree *o = (tree *) alloca (noutputs * sizeof (tree));
6956   tree tail;
6957
6958   /* Record the contents of OUTPUTS before it is modified.  */
6959   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6960     {
6961       o[i] = TREE_VALUE (tail);
6962       if (o[i] == error_mark_node)
6963         return;
6964     }
6965
6966   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6967      OUTPUTS some trees for where the values were actually stored.  */
6968   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6969
6970   /* Copy all the intermediate outputs into the specified outputs.  */
6971   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6972     {
6973       if (o[i] != TREE_VALUE (tail))
6974         {
6975           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6976                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6977           free_temp_slots ();
6978
6979           /* Restore the original value so that it's correct the next
6980              time we expand this function.  */
6981           TREE_VALUE (tail) = o[i];
6982         }
6983       /* Detect modification of read-only values.
6984          (Otherwise done by build_modify_expr.)  */
6985       else
6986         {
6987           tree type = TREE_TYPE (o[i]);
6988           if (TREE_READONLY (o[i])
6989               || TYPE_READONLY (type)
6990               || ((TREE_CODE (type) == RECORD_TYPE
6991                    || TREE_CODE (type) == UNION_TYPE)
6992                   && C_TYPE_FIELDS_READONLY (type)))
6993             readonly_warning (o[i], "modification by `asm'");
6994         }
6995     }
6996
6997   /* Those MODIFY_EXPRs could do autoincrements.  */
6998   emit_queue ();
6999 }
7000 \f
7001 /* Expand a C `return' statement.
7002    RETVAL is the expression for what to return,
7003    or a null pointer for `return;' with no value.  */
7004
7005 tree
7006 c_expand_return (retval)
7007      tree retval;
7008 {
7009   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
7010
7011   if (TREE_THIS_VOLATILE (current_function_decl))
7012     warning ("function declared `noreturn' has a `return' statement");
7013
7014   if (!retval)
7015     {
7016       current_function_returns_null = 1;
7017       if ((warn_return_type || flag_isoc99)
7018           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
7019         pedwarn_c99 ("`return' with no value, in function returning non-void");
7020     }
7021   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
7022     {
7023       current_function_returns_null = 1;
7024       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7025         pedwarn ("`return' with a value, in function returning void");
7026     }
7027   else
7028     {
7029       tree t = convert_for_assignment (valtype, retval, _("return"),
7030                                        NULL_TREE, NULL_TREE, 0);
7031       tree res = DECL_RESULT (current_function_decl);
7032       tree inner;
7033
7034       current_function_returns_value = 1;
7035       if (t == error_mark_node)
7036         return NULL_TREE;
7037
7038       inner = t = convert (TREE_TYPE (res), t);
7039
7040       /* Strip any conversions, additions, and subtractions, and see if
7041          we are returning the address of a local variable.  Warn if so.  */
7042       while (1)
7043         {
7044           switch (TREE_CODE (inner))
7045             {
7046             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
7047             case PLUS_EXPR:
7048               inner = TREE_OPERAND (inner, 0);
7049               continue;
7050
7051             case MINUS_EXPR:
7052               /* If the second operand of the MINUS_EXPR has a pointer
7053                  type (or is converted from it), this may be valid, so
7054                  don't give a warning.  */
7055               {
7056                 tree op1 = TREE_OPERAND (inner, 1);
7057
7058                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
7059                        && (TREE_CODE (op1) == NOP_EXPR
7060                            || TREE_CODE (op1) == NON_LVALUE_EXPR
7061                            || TREE_CODE (op1) == CONVERT_EXPR))
7062                   op1 = TREE_OPERAND (op1, 0);
7063
7064                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7065                   break;
7066
7067                 inner = TREE_OPERAND (inner, 0);
7068                 continue;
7069               }
7070
7071             case ADDR_EXPR:
7072               inner = TREE_OPERAND (inner, 0);
7073
7074               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
7075                 inner = TREE_OPERAND (inner, 0);
7076
7077               if (TREE_CODE (inner) == VAR_DECL
7078                   && ! DECL_EXTERNAL (inner)
7079                   && ! TREE_STATIC (inner)
7080                   && DECL_CONTEXT (inner) == current_function_decl)
7081                 warning ("function returns address of local variable");
7082               break;
7083
7084             default:
7085               break;
7086             }
7087
7088           break;
7089         }
7090
7091       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
7092     }
7093
7094  return add_stmt (build_return_stmt (retval));
7095 }
7096 \f
7097 struct c_switch {
7098   /* The SWITCH_STMT being built.  */
7099   tree switch_stmt;
7100   /* A splay-tree mapping the low element of a case range to the high
7101      element, or NULL_TREE if there is no high element.  Used to
7102      determine whether or not a new case label duplicates an old case
7103      label.  We need a tree, rather than simply a hash table, because
7104      of the GNU case range extension.  */
7105   splay_tree cases;
7106   /* The next node on the stack.  */
7107   struct c_switch *next;
7108 };
7109
7110 /* A stack of the currently active switch statements.  The innermost
7111    switch statement is on the top of the stack.  There is no need to
7112    mark the stack for garbage collection because it is only active
7113    during the processing of the body of a function, and we never
7114    collect at that point.  */
7115
7116 static struct c_switch *switch_stack;
7117
7118 /* Start a C switch statement, testing expression EXP.  Return the new
7119    SWITCH_STMT.  */
7120
7121 tree
7122 c_start_case (exp)
7123      tree exp;
7124 {
7125   enum tree_code code;
7126   tree type, orig_type = error_mark_node;
7127   struct c_switch *cs;
7128
7129   if (exp != error_mark_node)
7130     {
7131       code = TREE_CODE (TREE_TYPE (exp));
7132       orig_type = TREE_TYPE (exp);
7133
7134       if (! INTEGRAL_TYPE_P (orig_type)
7135           && code != ERROR_MARK)
7136         {
7137           error ("switch quantity not an integer");
7138           exp = integer_zero_node;
7139         }
7140       else
7141         {
7142           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7143
7144           if (warn_traditional && !in_system_header
7145               && (type == long_integer_type_node
7146                   || type == long_unsigned_type_node))
7147             warning ("`long' switch expression not converted to `int' in ISO C");
7148
7149           exp = default_conversion (exp);
7150           type = TREE_TYPE (exp);
7151         }
7152     }
7153
7154   /* Add this new SWITCH_STMT to the stack.  */
7155   cs = (struct c_switch *) xmalloc (sizeof (*cs));
7156   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
7157   cs->cases = splay_tree_new (case_compare, NULL, NULL);
7158   cs->next = switch_stack;
7159   switch_stack = cs;
7160
7161   return add_stmt (switch_stack->switch_stmt);
7162 }
7163
7164 /* Process a case label.  */
7165
7166 tree
7167 do_case (low_value, high_value)
7168      tree low_value;
7169      tree high_value;
7170 {
7171   tree label = NULL_TREE;
7172
7173   if (switch_stack)
7174     {
7175       label = c_add_case_label (switch_stack->cases,
7176                                 SWITCH_COND (switch_stack->switch_stmt),
7177                                 low_value, high_value);
7178       if (label == error_mark_node)
7179         label = NULL_TREE;
7180     }
7181   else if (low_value)
7182     error ("case label not within a switch statement");
7183   else
7184     error ("`default' label not within a switch statement");
7185
7186   return label;
7187 }
7188
7189 /* Finish the switch statement.  */
7190
7191 void
7192 c_finish_case ()
7193 {
7194   struct c_switch *cs = switch_stack;
7195
7196   RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7197
7198   /* Pop the stack.  */
7199   switch_stack = switch_stack->next;
7200   splay_tree_delete (cs->cases);
7201   free (cs);
7202 }