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