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