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 && (name || assembler_name))
1514     check_function_format (NULL, name, assembler_name, 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               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4694               /* Subtract 1 (or sizeof (wchar_t))
4695                  because it's ok to ignore the terminating null char
4696                  that is counted in the length of the constant.  */
4697               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4698                                        TREE_STRING_LENGTH (inside_init)
4699                                        - ((TYPE_PRECISION (typ1)
4700                                            != TYPE_PRECISION (char_type_node))
4701                                           ? (TYPE_PRECISION (wchar_type_node)
4702                                              / BITS_PER_UNIT)
4703                                           : 1)))
4704             pedwarn_init ("initializer-string for array of chars is too long");
4705
4706           return inside_init;
4707         }
4708     }
4709
4710   /* Any type can be initialized
4711      from an expression of the same type, optionally with braces.  */
4712
4713   if (inside_init && TREE_TYPE (inside_init) != 0
4714       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4715                      TYPE_MAIN_VARIANT (type))
4716           || (code == ARRAY_TYPE
4717               && comptypes (TREE_TYPE (inside_init), type))
4718           || (code == POINTER_TYPE
4719               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4720                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4721               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4722                             TREE_TYPE (type)))))
4723     {
4724       if (code == POINTER_TYPE
4725           && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4726               || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4727         inside_init = default_conversion (inside_init);
4728       else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4729                && TREE_CODE (inside_init) != CONSTRUCTOR)
4730         {
4731           error_init ("array initialized from non-constant array expression");
4732           return error_mark_node;
4733         }
4734
4735       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4736         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4737
4738       /* Compound expressions can only occur here if -pedantic or
4739          -pedantic-errors is specified.  In the later case, we always want
4740          an error.  In the former case, we simply want a warning.  */
4741       if (require_constant && pedantic
4742           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4743         {
4744           inside_init
4745             = valid_compound_expr_initializer (inside_init,
4746                                                TREE_TYPE (inside_init));
4747           if (inside_init == error_mark_node)
4748             error_init ("initializer element is not constant");
4749           else
4750             pedwarn_init ("initializer element is not constant");
4751           if (flag_pedantic_errors)
4752             inside_init = error_mark_node;
4753         }
4754       else if (require_constant
4755                && (!TREE_CONSTANT (inside_init)
4756                    /* This test catches things like `7 / 0' which
4757                       result in an expression for which TREE_CONSTANT
4758                       is true, but which is not actually something
4759                       that is a legal constant.  We really should not
4760                       be using this function, because it is a part of
4761                       the back-end.  Instead, the expression should
4762                       already have been turned into ERROR_MARK_NODE.  */
4763                    || !initializer_constant_valid_p (inside_init,
4764                                                      TREE_TYPE (inside_init))))
4765         {
4766           error_init ("initializer element is not constant");
4767           inside_init = error_mark_node;
4768         }
4769
4770       return inside_init;
4771     }
4772
4773   /* Handle scalar types, including conversions.  */
4774
4775   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4776       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4777     {
4778       /* Note that convert_for_assignment calls default_conversion
4779          for arrays and functions.  We must not call it in the
4780          case where inside_init is a null pointer constant.  */
4781       inside_init
4782         = convert_for_assignment (type, init, _("initialization"),
4783                                   NULL_TREE, NULL_TREE, 0);
4784
4785       if (require_constant && ! TREE_CONSTANT (inside_init))
4786         {
4787           error_init ("initializer element is not constant");
4788           inside_init = error_mark_node;
4789         }
4790       else if (require_constant
4791                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4792         {
4793           error_init ("initializer element is not computable at load time");
4794           inside_init = error_mark_node;
4795         }
4796
4797       return inside_init;
4798     }
4799
4800   /* Come here only for records and arrays.  */
4801
4802   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4803     {
4804       error_init ("variable-sized object may not be initialized");
4805       return error_mark_node;
4806     }
4807
4808   /* Traditionally, you can write  struct foo x = 0;
4809      and it initializes the first element of x to 0.  */
4810   if (flag_traditional)
4811     {
4812       tree top = 0, prev = 0, otype = type;
4813       while (TREE_CODE (type) == RECORD_TYPE
4814              || TREE_CODE (type) == ARRAY_TYPE
4815              || TREE_CODE (type) == QUAL_UNION_TYPE
4816              || TREE_CODE (type) == UNION_TYPE)
4817         {
4818           tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4819           if (prev == 0)
4820             top = temp;
4821           else
4822             TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4823           prev = temp;
4824           if (TREE_CODE (type) == ARRAY_TYPE)
4825             type = TREE_TYPE (type);
4826           else if (TYPE_FIELDS (type))
4827             type = TREE_TYPE (TYPE_FIELDS (type));
4828           else
4829             {
4830               error_init ("invalid initializer");
4831               return error_mark_node;
4832             }
4833         }
4834
4835       if (otype != type)
4836         {
4837           TREE_OPERAND (prev, 1)
4838             = build_tree_list (NULL_TREE,
4839                                digest_init (type, init, require_constant,
4840                                             constructor_constant));
4841           return top;
4842         }
4843       else
4844         return error_mark_node;
4845     }
4846   error_init ("invalid initializer");
4847   return error_mark_node;
4848 }
4849 \f
4850 /* Handle initializers that use braces.  */
4851
4852 /* Type of object we are accumulating a constructor for.
4853    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4854 static tree constructor_type;
4855
4856 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4857    left to fill.  */
4858 static tree constructor_fields;
4859
4860 /* For an ARRAY_TYPE, this is the specified index
4861    at which to store the next element we get.  */
4862 static tree constructor_index;
4863
4864 /* For an ARRAY_TYPE, this is the maximum index.  */
4865 static tree constructor_max_index;
4866
4867 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4868 static tree constructor_unfilled_fields;
4869
4870 /* For an ARRAY_TYPE, this is the index of the first element
4871    not yet written out.  */
4872 static tree constructor_unfilled_index;
4873
4874 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4875    This is so we can generate gaps between fields, when appropriate.  */
4876 static tree constructor_bit_index;
4877
4878 /* If we are saving up the elements rather than allocating them,
4879    this is the list of elements so far (in reverse order,
4880    most recent first).  */
4881 static tree constructor_elements;
4882
4883 /* 1 if constructor should be incrementally stored into a constructor chain,
4884    0 if all the elements should be kept in AVL tree.  */
4885 static int constructor_incremental;
4886
4887 /* 1 if so far this constructor's elements are all compile-time constants.  */
4888 static int constructor_constant;
4889
4890 /* 1 if so far this constructor's elements are all valid address constants.  */
4891 static int constructor_simple;
4892
4893 /* 1 if this constructor is erroneous so far.  */
4894 static int constructor_erroneous;
4895
4896 /* 1 if have called defer_addressed_constants.  */
4897 static int constructor_subconstants_deferred;
4898
4899 /* Structure for managing pending initializer elements, organized as an
4900    AVL tree.  */
4901
4902 struct init_node
4903 {
4904   struct init_node *left, *right;
4905   struct init_node *parent;
4906   int balance;
4907   tree purpose;
4908   tree value;
4909 };
4910
4911 /* Tree of pending elements at this constructor level.
4912    These are elements encountered out of order
4913    which belong at places we haven't reached yet in actually
4914    writing the output.
4915    Will never hold tree nodes across GC runs.  */
4916 static struct init_node *constructor_pending_elts;
4917
4918 /* The SPELLING_DEPTH of this constructor.  */
4919 static int constructor_depth;
4920
4921 /* 0 if implicitly pushing constructor levels is allowed.  */
4922 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4923
4924 static int require_constant_value;
4925 static int require_constant_elements;
4926
4927 /* DECL node for which an initializer is being read.
4928    0 means we are reading a constructor expression
4929    such as (struct foo) {...}.  */
4930 static tree constructor_decl;
4931
4932 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4933 static const char *constructor_asmspec;
4934
4935 /* Nonzero if this is an initializer for a top-level decl.  */
4936 static int constructor_top_level;
4937
4938 /* Nesting depth of designator list.  */
4939 static int designator_depth;
4940
4941 /* Nonzero if there were diagnosed errors in this designator list.  */
4942 static int designator_errorneous;
4943
4944 \f
4945 /* This stack has a level for each implicit or explicit level of
4946    structuring in the initializer, including the outermost one.  It
4947    saves the values of most of the variables above.  */
4948
4949 struct constructor_range_stack;
4950
4951 struct constructor_stack
4952 {
4953   struct constructor_stack *next;
4954   tree type;
4955   tree fields;
4956   tree index;
4957   tree max_index;
4958   tree unfilled_index;
4959   tree unfilled_fields;
4960   tree bit_index;
4961   tree elements;
4962   struct init_node *pending_elts;
4963   int offset;
4964   int depth;
4965   /* If nonzero, this value should replace the entire
4966      constructor at this level.  */
4967   tree replacement_value;
4968   struct constructor_range_stack *range_stack;
4969   char constant;
4970   char simple;
4971   char implicit;
4972   char erroneous;
4973   char outer;
4974   char incremental;
4975 };
4976
4977 struct constructor_stack *constructor_stack;
4978
4979 /* This stack represents designators from some range designator up to
4980    the last designator in the list.  */
4981
4982 struct constructor_range_stack
4983 {
4984   struct constructor_range_stack *next, *prev;
4985   struct constructor_stack *stack;
4986   tree range_start;
4987   tree index;
4988   tree range_end;
4989   tree fields;
4990 };
4991
4992 struct constructor_range_stack *constructor_range_stack;
4993
4994 /* This stack records separate initializers that are nested.
4995    Nested initializers can't happen in ANSI C, but GNU C allows them
4996    in cases like { ... (struct foo) { ... } ... }.  */
4997
4998 struct initializer_stack
4999 {
5000   struct initializer_stack *next;
5001   tree decl;
5002   const char *asmspec;
5003   struct constructor_stack *constructor_stack;
5004   struct constructor_range_stack *constructor_range_stack;
5005   tree elements;
5006   struct spelling *spelling;
5007   struct spelling *spelling_base;
5008   int spelling_size;
5009   char top_level;
5010   char require_constant_value;
5011   char require_constant_elements;
5012   char deferred;
5013 };
5014
5015 struct initializer_stack *initializer_stack;
5016 \f
5017 /* Prepare to parse and output the initializer for variable DECL.  */
5018
5019 void
5020 start_init (decl, asmspec_tree, top_level)
5021      tree decl;
5022      tree asmspec_tree;
5023      int top_level;
5024 {
5025   const char *locus;
5026   struct initializer_stack *p
5027     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5028   const char *asmspec = 0;
5029
5030   if (asmspec_tree)
5031     asmspec = TREE_STRING_POINTER (asmspec_tree);
5032
5033   p->decl = constructor_decl;
5034   p->asmspec = constructor_asmspec;
5035   p->require_constant_value = require_constant_value;
5036   p->require_constant_elements = require_constant_elements;
5037   p->constructor_stack = constructor_stack;
5038   p->constructor_range_stack = constructor_range_stack;
5039   p->elements = constructor_elements;
5040   p->spelling = spelling;
5041   p->spelling_base = spelling_base;
5042   p->spelling_size = spelling_size;
5043   p->deferred = constructor_subconstants_deferred;
5044   p->top_level = constructor_top_level;
5045   p->next = initializer_stack;
5046   initializer_stack = p;
5047
5048   constructor_decl = decl;
5049   constructor_asmspec = asmspec;
5050   constructor_subconstants_deferred = 0;
5051   constructor_top_level = top_level;
5052
5053   if (decl != 0)
5054     {
5055       require_constant_value = TREE_STATIC (decl);
5056       require_constant_elements
5057         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5058            /* For a scalar, you can always use any value to initialize,
5059               even within braces.  */
5060            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5061                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5062                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5063                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5064       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5065     }
5066   else
5067     {
5068       require_constant_value = 0;
5069       require_constant_elements = 0;
5070       locus = "(anonymous)";
5071     }
5072
5073   constructor_stack = 0;
5074   constructor_range_stack = 0;
5075
5076   missing_braces_mentioned = 0;
5077
5078   spelling_base = 0;
5079   spelling_size = 0;
5080   RESTORE_SPELLING_DEPTH (0);
5081
5082   if (locus)
5083     push_string (locus);
5084 }
5085
5086 void
5087 finish_init ()
5088 {
5089   struct initializer_stack *p = initializer_stack;
5090
5091   /* Output subconstants (string constants, usually)
5092      that were referenced within this initializer and saved up.
5093      Must do this if and only if we called defer_addressed_constants.  */
5094   if (constructor_subconstants_deferred)
5095     output_deferred_addressed_constants ();
5096
5097   /* Free the whole constructor stack of this initializer.  */
5098   while (constructor_stack)
5099     {
5100       struct constructor_stack *q = constructor_stack;
5101       constructor_stack = q->next;
5102       free (q);
5103     }
5104
5105   if (constructor_range_stack)
5106     abort ();
5107
5108   /* Pop back to the data of the outer initializer (if any).  */
5109   constructor_decl = p->decl;
5110   constructor_asmspec = p->asmspec;
5111   require_constant_value = p->require_constant_value;
5112   require_constant_elements = p->require_constant_elements;
5113   constructor_stack = p->constructor_stack;
5114   constructor_range_stack = p->constructor_range_stack;
5115   constructor_elements = p->elements;
5116   spelling = p->spelling;
5117   spelling_base = p->spelling_base;
5118   spelling_size = p->spelling_size;
5119   constructor_subconstants_deferred = p->deferred;
5120   constructor_top_level = p->top_level;
5121   initializer_stack = p->next;
5122   free (p);
5123 }
5124 \f
5125 /* Call here when we see the initializer is surrounded by braces.
5126    This is instead of a call to push_init_level;
5127    it is matched by a call to pop_init_level.
5128
5129    TYPE is the type to initialize, for a constructor expression.
5130    For an initializer for a decl, TYPE is zero.  */
5131
5132 void
5133 really_start_incremental_init (type)
5134      tree type;
5135 {
5136   struct constructor_stack *p
5137     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5138
5139   if (type == 0)
5140     type = TREE_TYPE (constructor_decl);
5141
5142   p->type = constructor_type;
5143   p->fields = constructor_fields;
5144   p->index = constructor_index;
5145   p->max_index = constructor_max_index;
5146   p->unfilled_index = constructor_unfilled_index;
5147   p->unfilled_fields = constructor_unfilled_fields;
5148   p->bit_index = constructor_bit_index;
5149   p->elements = constructor_elements;
5150   p->constant = constructor_constant;
5151   p->simple = constructor_simple;
5152   p->erroneous = constructor_erroneous;
5153   p->pending_elts = constructor_pending_elts;
5154   p->depth = constructor_depth;
5155   p->replacement_value = 0;
5156   p->implicit = 0;
5157   p->range_stack = 0;
5158   p->outer = 0;
5159   p->incremental = constructor_incremental;
5160   p->next = 0;
5161   constructor_stack = p;
5162
5163   constructor_constant = 1;
5164   constructor_simple = 1;
5165   constructor_depth = SPELLING_DEPTH ();
5166   constructor_elements = 0;
5167   constructor_pending_elts = 0;
5168   constructor_type = type;
5169   constructor_incremental = 1;
5170   designator_depth = 0;
5171   designator_errorneous = 0;
5172
5173   if (TREE_CODE (constructor_type) == RECORD_TYPE
5174       || TREE_CODE (constructor_type) == UNION_TYPE)
5175     {
5176       constructor_fields = TYPE_FIELDS (constructor_type);
5177       /* Skip any nameless bit fields at the beginning.  */
5178       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5179              && DECL_NAME (constructor_fields) == 0)
5180         constructor_fields = TREE_CHAIN (constructor_fields);
5181
5182       constructor_unfilled_fields = constructor_fields;
5183       constructor_bit_index = bitsize_zero_node;
5184     }
5185   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5186     {
5187       if (TYPE_DOMAIN (constructor_type))
5188         {
5189           constructor_max_index
5190             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5191
5192           /* Detect non-empty initializations of zero-length arrays.  */
5193           if (constructor_max_index == NULL_TREE
5194               && TYPE_SIZE (constructor_type))
5195             constructor_max_index = build_int_2 (-1, -1);
5196
5197           constructor_index
5198             = convert (bitsizetype,
5199                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5200         }
5201       else
5202         constructor_index = bitsize_zero_node;
5203
5204       constructor_unfilled_index = constructor_index;
5205     }
5206   else
5207     {
5208       /* Handle the case of int x = {5}; */
5209       constructor_fields = constructor_type;
5210       constructor_unfilled_fields = constructor_type;
5211     }
5212 }
5213 \f
5214 /* Push down into a subobject, for initialization.
5215    If this is for an explicit set of braces, IMPLICIT is 0.
5216    If it is because the next element belongs at a lower level,
5217    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
5218
5219 void
5220 push_init_level (implicit)
5221      int implicit;
5222 {
5223   struct constructor_stack *p;
5224   tree value = NULL_TREE;
5225
5226   /* If we've exhausted any levels that didn't have braces,
5227      pop them now.  */
5228   while (constructor_stack->implicit)
5229     {
5230       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5231            || TREE_CODE (constructor_type) == UNION_TYPE)
5232           && constructor_fields == 0)
5233         process_init_element (pop_init_level (1));
5234       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5235                && tree_int_cst_lt (constructor_max_index, constructor_index))
5236         process_init_element (pop_init_level (1));
5237       else
5238         break;
5239     }
5240
5241   /* Unless this is an explicit brace, we need to preserve previous
5242      content if any.  */
5243   if (implicit)
5244     {
5245       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5246            || TREE_CODE (constructor_type) == UNION_TYPE)
5247           && constructor_fields)
5248         value = find_init_member (constructor_fields);
5249       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5250         value = find_init_member (constructor_index);
5251     }
5252
5253   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5254   p->type = constructor_type;
5255   p->fields = constructor_fields;
5256   p->index = constructor_index;
5257   p->max_index = constructor_max_index;
5258   p->unfilled_index = constructor_unfilled_index;
5259   p->unfilled_fields = constructor_unfilled_fields;
5260   p->bit_index = constructor_bit_index;
5261   p->elements = constructor_elements;
5262   p->constant = constructor_constant;
5263   p->simple = constructor_simple;
5264   p->erroneous = constructor_erroneous;
5265   p->pending_elts = constructor_pending_elts;
5266   p->depth = constructor_depth;
5267   p->replacement_value = 0;
5268   p->implicit = implicit;
5269   p->outer = 0;
5270   p->incremental = constructor_incremental;
5271   p->next = constructor_stack;
5272   p->range_stack = 0;
5273   constructor_stack = p;
5274
5275   constructor_constant = 1;
5276   constructor_simple = 1;
5277   constructor_depth = SPELLING_DEPTH ();
5278   constructor_elements = 0;
5279   constructor_incremental = 1;
5280   constructor_pending_elts = 0;
5281   if (!implicit)
5282     {
5283       p->range_stack = constructor_range_stack;
5284       constructor_range_stack = 0;
5285       designator_depth = 0;
5286       designator_errorneous = 0;
5287     }
5288
5289   /* Don't die if an entire brace-pair level is superfluous
5290      in the containing level.  */
5291   if (constructor_type == 0)
5292     ;
5293   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5294            || TREE_CODE (constructor_type) == UNION_TYPE)
5295     {
5296       /* Don't die if there are extra init elts at the end.  */
5297       if (constructor_fields == 0)
5298         constructor_type = 0;
5299       else
5300         {
5301           constructor_type = TREE_TYPE (constructor_fields);
5302           push_member_name (constructor_fields);
5303           constructor_depth++;
5304         }
5305     }
5306   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5307     {
5308       constructor_type = TREE_TYPE (constructor_type);
5309       push_array_bounds (tree_low_cst (constructor_index, 0));
5310       constructor_depth++;
5311     }
5312
5313   if (constructor_type == 0)
5314     {
5315       error_init ("extra brace group at end of initializer");
5316       constructor_fields = 0;
5317       constructor_unfilled_fields = 0;
5318       return;
5319     }
5320
5321   if (value && TREE_CODE (value) == CONSTRUCTOR)
5322     {
5323       constructor_constant = TREE_CONSTANT (value);
5324       constructor_simple = TREE_STATIC (value);
5325       constructor_elements = TREE_OPERAND (value, 1);
5326       if (constructor_elements
5327           && (TREE_CODE (constructor_type) == RECORD_TYPE
5328               || TREE_CODE (constructor_type) == ARRAY_TYPE))
5329         set_nonincremental_init ();
5330     }
5331
5332   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5333     {
5334       missing_braces_mentioned = 1;
5335       warning_init ("missing braces around initializer");
5336     }
5337
5338   if (TREE_CODE (constructor_type) == RECORD_TYPE
5339            || TREE_CODE (constructor_type) == UNION_TYPE)
5340     {
5341       constructor_fields = TYPE_FIELDS (constructor_type);
5342       /* Skip any nameless bit fields at the beginning.  */
5343       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5344              && DECL_NAME (constructor_fields) == 0)
5345         constructor_fields = TREE_CHAIN (constructor_fields);
5346
5347       constructor_unfilled_fields = constructor_fields;
5348       constructor_bit_index = bitsize_zero_node;
5349     }
5350   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5351     {
5352       if (TYPE_DOMAIN (constructor_type))
5353         {
5354           constructor_max_index
5355             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5356
5357           /* Detect non-empty initializations of zero-length arrays.  */
5358           if (constructor_max_index == NULL_TREE
5359               && TYPE_SIZE (constructor_type))
5360             constructor_max_index = build_int_2 (-1, -1);
5361
5362           constructor_index
5363             = convert (bitsizetype,
5364                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5365         }
5366       else
5367         constructor_index = bitsize_zero_node;
5368
5369       constructor_unfilled_index = constructor_index;
5370       if (value && TREE_CODE (value) == STRING_CST)
5371         {
5372           /* We need to split the char/wchar array into individual
5373              characters, so that we don't have to special case it
5374              everywhere.  */
5375           set_nonincremental_init_from_string (value);
5376         }
5377     }
5378   else
5379     {
5380       warning_init ("braces around scalar initializer");
5381       constructor_fields = constructor_type;
5382       constructor_unfilled_fields = constructor_type;
5383     }
5384 }
5385
5386 /* At the end of an implicit or explicit brace level,
5387    finish up that level of constructor.
5388    If we were outputting the elements as they are read, return 0
5389    from inner levels (process_init_element ignores that),
5390    but return error_mark_node from the outermost level
5391    (that's what we want to put in DECL_INITIAL).
5392    Otherwise, return a CONSTRUCTOR expression.  */
5393
5394 tree
5395 pop_init_level (implicit)
5396      int implicit;
5397 {
5398   struct constructor_stack *p;
5399   HOST_WIDE_INT size = 0;
5400   tree constructor = 0;
5401
5402   if (implicit == 0)
5403     {
5404       /* When we come to an explicit close brace,
5405          pop any inner levels that didn't have explicit braces.  */
5406       while (constructor_stack->implicit)
5407         process_init_element (pop_init_level (1));
5408
5409       if (constructor_range_stack)
5410         abort ();
5411     }
5412
5413   p = constructor_stack;
5414
5415   if (constructor_type != 0)
5416     size = int_size_in_bytes (constructor_type);
5417
5418   /* Error for initializing a flexible array member, or a zero-length
5419      array member in an inappropriate context.  */
5420   if (constructor_type && constructor_fields
5421       && TREE_CODE (constructor_type) == ARRAY_TYPE
5422       && TYPE_DOMAIN (constructor_type)
5423       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5424     {
5425       /* Silently discard empty initializations.  The parser will
5426          already have pedwarned for empty brackets.  */
5427       if (integer_zerop (constructor_unfilled_index))
5428         constructor_type = NULL_TREE;
5429       else if (! TYPE_SIZE (constructor_type))
5430         {
5431           if (constructor_depth > 2)
5432             error_init ("initialization of flexible array member in a nested context");
5433           else if (pedantic)
5434             pedwarn_init ("initialization of a flexible array member");
5435
5436           /* We have already issued an error message for the existance
5437              of a flexible array member not at the end of the structure.
5438              Discard the initializer so that we do not abort later.  */
5439           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5440             constructor_type = NULL_TREE;
5441         }
5442       else
5443         /* Zero-length arrays are no longer special, so we should no longer
5444            get here.  */
5445         abort();
5446     }
5447
5448   /* Warn when some struct elements are implicitly initialized to zero.  */
5449   if (extra_warnings
5450       && constructor_type
5451       && TREE_CODE (constructor_type) == RECORD_TYPE
5452       && constructor_unfilled_fields)
5453     {
5454         /* Do not warn for flexible array members or zero-length arrays.  */
5455         while (constructor_unfilled_fields
5456                && (! DECL_SIZE (constructor_unfilled_fields)
5457                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5458           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5459
5460         if (constructor_unfilled_fields)
5461           {
5462             push_member_name (constructor_unfilled_fields);
5463             warning_init ("missing initializer");
5464             RESTORE_SPELLING_DEPTH (constructor_depth);
5465           }
5466     }
5467
5468   /* Now output all pending elements.  */
5469   constructor_incremental = 1;
5470   output_pending_init_elements (1);
5471
5472   /* Pad out the end of the structure.  */
5473   if (p->replacement_value)
5474     /* If this closes a superfluous brace pair,
5475        just pass out the element between them.  */
5476     constructor = p->replacement_value;
5477   else if (constructor_type == 0)
5478     ;
5479   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5480            && TREE_CODE (constructor_type) != UNION_TYPE
5481            && TREE_CODE (constructor_type) != ARRAY_TYPE)
5482     {
5483       /* A nonincremental scalar initializer--just return
5484          the element, after verifying there is just one.  */
5485       if (constructor_elements == 0)
5486         {
5487           if (!constructor_erroneous)
5488             error_init ("empty scalar initializer");
5489           constructor = error_mark_node;
5490         }
5491       else if (TREE_CHAIN (constructor_elements) != 0)
5492         {
5493           error_init ("extra elements in scalar initializer");
5494           constructor = TREE_VALUE (constructor_elements);
5495         }
5496       else
5497         constructor = TREE_VALUE (constructor_elements);
5498     }
5499   else
5500     {
5501       if (constructor_erroneous)
5502         constructor = error_mark_node;
5503       else
5504         {
5505           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5506                                nreverse (constructor_elements));
5507           if (constructor_constant)
5508             TREE_CONSTANT (constructor) = 1;
5509           if (constructor_constant && constructor_simple)
5510             TREE_STATIC (constructor) = 1;
5511         }
5512     }
5513
5514   constructor_type = p->type;
5515   constructor_fields = p->fields;
5516   constructor_index = p->index;
5517   constructor_max_index = p->max_index;
5518   constructor_unfilled_index = p->unfilled_index;
5519   constructor_unfilled_fields = p->unfilled_fields;
5520   constructor_bit_index = p->bit_index;
5521   constructor_elements = p->elements;
5522   constructor_constant = p->constant;
5523   constructor_simple = p->simple;
5524   constructor_erroneous = p->erroneous;
5525   constructor_incremental = p->incremental;
5526   constructor_pending_elts = p->pending_elts;
5527   constructor_depth = p->depth;
5528   if (!p->implicit)
5529     constructor_range_stack = p->range_stack;
5530   RESTORE_SPELLING_DEPTH (constructor_depth);
5531
5532   constructor_stack = p->next;
5533   free (p);
5534
5535   if (constructor == 0)
5536     {
5537       if (constructor_stack == 0)
5538         return error_mark_node;
5539       return NULL_TREE;
5540     }
5541   return constructor;
5542 }
5543
5544 /* Common handling for both array range and field name designators.
5545    ARRAY argument is non-zero for array ranges.  Returns zero for success.  */
5546
5547 static int
5548 set_designator (array)
5549      int array;
5550 {
5551   tree subtype;
5552   enum tree_code subcode;
5553
5554   /* Don't die if an entire brace-pair level is superfluous
5555      in the containing level.  */
5556   if (constructor_type == 0)
5557     return 1;
5558
5559   /* If there were errors in this designator list already, bail out silently.  */
5560   if (designator_errorneous)
5561     return 1;
5562
5563   if (!designator_depth)
5564     {
5565       if (constructor_range_stack)
5566         abort ();
5567
5568       /* Designator list starts at the level of closest explicit
5569          braces.  */
5570       while (constructor_stack->implicit)
5571         process_init_element (pop_init_level (1));
5572       return 0;
5573     }
5574
5575   if (constructor_no_implicit)
5576     {
5577       error_init ("initialization designators may not nest");
5578       return 1;
5579     }
5580
5581   if (TREE_CODE (constructor_type) == RECORD_TYPE
5582       || TREE_CODE (constructor_type) == UNION_TYPE)
5583     {
5584       subtype = TREE_TYPE (constructor_fields);
5585       if (subtype != error_mark_node)
5586         subtype = TYPE_MAIN_VARIANT (subtype);
5587     }
5588   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5589     {
5590       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5591     }
5592   else
5593     abort ();
5594
5595   subcode = TREE_CODE (subtype);
5596   if (array && subcode != ARRAY_TYPE)
5597     {
5598       error_init ("array index in non-array initializer");
5599       return 1;
5600     }
5601   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5602     {
5603       error_init ("field name not in record or union initializer");
5604       return 1;
5605     }
5606
5607   push_init_level (2);
5608   return 0;
5609 }
5610
5611 /* If there are range designators in designator list, push a new designator
5612    to constructor_range_stack.  RANGE_END is end of such stack range or
5613    NULL_TREE if there is no range designator at this level.  */
5614
5615 static void
5616 push_range_stack (range_end)
5617      tree range_end;
5618 {
5619   struct constructor_range_stack *p;
5620
5621   p = (struct constructor_range_stack *)
5622       ggc_alloc (sizeof (struct constructor_range_stack));
5623   p->prev = constructor_range_stack;
5624   p->next = 0;
5625   p->fields = constructor_fields;
5626   p->range_start = constructor_index;
5627   p->index = constructor_index;
5628   p->stack = constructor_stack;
5629   p->range_end = range_end;
5630   if (constructor_range_stack)
5631     constructor_range_stack->next = p;
5632   constructor_range_stack = p;
5633 }
5634
5635 /* Within an array initializer, specify the next index to be initialized.
5636    FIRST is that index.  If LAST is nonzero, then initialize a range
5637    of indices, running from FIRST through LAST.  */
5638
5639 void
5640 set_init_index (first, last)
5641      tree first, last;
5642 {
5643   if (set_designator (1))
5644     return;
5645
5646   designator_errorneous = 1;
5647
5648   while ((TREE_CODE (first) == NOP_EXPR
5649           || TREE_CODE (first) == CONVERT_EXPR
5650           || TREE_CODE (first) == NON_LVALUE_EXPR)
5651          && (TYPE_MODE (TREE_TYPE (first))
5652              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5653     first = TREE_OPERAND (first, 0);
5654
5655   if (last)
5656     while ((TREE_CODE (last) == NOP_EXPR
5657             || TREE_CODE (last) == CONVERT_EXPR
5658             || TREE_CODE (last) == NON_LVALUE_EXPR)
5659            && (TYPE_MODE (TREE_TYPE (last))
5660                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5661       last = TREE_OPERAND (last, 0);
5662
5663   if (TREE_CODE (first) != INTEGER_CST)
5664     error_init ("nonconstant array index in initializer");
5665   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5666     error_init ("nonconstant array index in initializer");
5667   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5668     error_init ("array index in non-array initializer");
5669   else if (constructor_max_index
5670            && tree_int_cst_lt (constructor_max_index, first))
5671     error_init ("array index in initializer exceeds array bounds");
5672   else
5673     {
5674       constructor_index = convert (bitsizetype, first);
5675
5676       if (last)
5677         {
5678           if (tree_int_cst_equal (first, last))
5679             last = 0;
5680           else if (tree_int_cst_lt (last, first))
5681             {
5682               error_init ("empty index range in initializer");
5683               last = 0;
5684             }
5685           else
5686             {
5687               last = convert (bitsizetype, last);
5688               if (constructor_max_index != 0
5689                   && tree_int_cst_lt (constructor_max_index, last))
5690                 {
5691                   error_init ("array index range in initializer exceeds array bounds");
5692                   last = 0;
5693                 }
5694             }
5695         }
5696
5697       designator_depth++;
5698       designator_errorneous = 0;
5699       if (constructor_range_stack || last)
5700         push_range_stack (last);
5701     }
5702 }
5703
5704 /* Within a struct initializer, specify the next field to be initialized.  */
5705
5706 void
5707 set_init_label (fieldname)
5708      tree fieldname;
5709 {
5710   tree tail;
5711
5712   if (set_designator (0))
5713     return;
5714
5715   designator_errorneous = 1;
5716
5717   if (TREE_CODE (constructor_type) != RECORD_TYPE
5718       && TREE_CODE (constructor_type) != UNION_TYPE)
5719     {
5720       error_init ("field name not in record or union initializer");
5721       return;
5722     }
5723
5724   for (tail = TYPE_FIELDS (constructor_type); tail;
5725        tail = TREE_CHAIN (tail))
5726     {
5727       if (DECL_NAME (tail) == fieldname)
5728         break;
5729     }
5730
5731   if (tail == 0)
5732     error ("unknown field `%s' specified in initializer",
5733            IDENTIFIER_POINTER (fieldname));
5734   else
5735     {
5736       constructor_fields = tail;
5737       designator_depth++;
5738       designator_errorneous = 0;
5739       if (constructor_range_stack)
5740         push_range_stack (NULL_TREE);
5741     }
5742 }
5743 \f
5744 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5745    indentifies the initializer, either array index or field in a structure.
5746    VALUE is the value of that index or field.  */
5747
5748 static void
5749 add_pending_init (purpose, value)
5750      tree purpose, value;
5751 {
5752   struct init_node *p, **q, *r;
5753
5754   q = &constructor_pending_elts;
5755   p = 0;
5756
5757   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5758     {
5759       while (*q != 0)
5760         {
5761           p = *q;
5762           if (tree_int_cst_lt (purpose, p->purpose))
5763             q = &p->left;
5764           else if (tree_int_cst_lt (p->purpose, purpose))
5765             q = &p->right;
5766           else
5767             {
5768               if (TREE_SIDE_EFFECTS (p->value))
5769                 warning_init ("initialized field with side-effects overwritten");
5770               p->value = value;
5771               return;
5772             }
5773         }
5774     }
5775   else
5776     {
5777       tree bitpos;
5778
5779       bitpos = bit_position (purpose);
5780       while (*q != NULL)
5781         {
5782           p = *q;
5783           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5784             q = &p->left;
5785           else if (p->purpose != purpose)
5786             q = &p->right;
5787           else
5788             {
5789               if (TREE_SIDE_EFFECTS (p->value))
5790                 warning_init ("initialized field with side-effects overwritten");
5791               p->value = value;
5792               return;
5793             }
5794         }
5795     }
5796
5797   r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5798   r->purpose = purpose;
5799   r->value = value;
5800
5801   *q = r;
5802   r->parent = p;
5803   r->left = 0;
5804   r->right = 0;
5805   r->balance = 0;
5806
5807   while (p)
5808     {
5809       struct init_node *s;
5810
5811       if (r == p->left)
5812         {
5813           if (p->balance == 0)
5814             p->balance = -1;
5815           else if (p->balance < 0)
5816             {
5817               if (r->balance < 0)
5818                 {
5819                   /* L rotation.  */
5820                   p->left = r->right;
5821                   if (p->left)
5822                     p->left->parent = p;
5823                   r->right = p;
5824
5825                   p->balance = 0;
5826                   r->balance = 0;
5827
5828                   s = p->parent;
5829                   p->parent = r;
5830                   r->parent = s;
5831                   if (s)
5832                     {
5833                       if (s->left == p)
5834                         s->left = r;
5835                       else
5836                         s->right = r;
5837                     }
5838                   else
5839                     constructor_pending_elts = r;
5840                 }
5841               else
5842                 {
5843                   /* LR rotation.  */
5844                   struct init_node *t = r->right;
5845
5846                   r->right = t->left;
5847                   if (r->right)
5848                     r->right->parent = r;
5849                   t->left = r;
5850
5851                   p->left = t->right;
5852                   if (p->left)
5853                     p->left->parent = p;
5854                   t->right = p;
5855
5856                   p->balance = t->balance < 0;
5857                   r->balance = -(t->balance > 0);
5858                   t->balance = 0;
5859
5860                   s = p->parent;
5861                   p->parent = t;
5862                   r->parent = t;
5863                   t->parent = s;
5864                   if (s)
5865                     {
5866                       if (s->left == p)
5867                         s->left = t;
5868                       else
5869                         s->right = t;
5870                     }
5871                   else
5872                     constructor_pending_elts = t;
5873                 }
5874               break;
5875             }
5876           else
5877             {
5878               /* p->balance == +1; growth of left side balances the node.  */
5879               p->balance = 0;
5880               break;
5881             }
5882         }
5883       else /* r == p->right */
5884         {
5885           if (p->balance == 0)
5886             /* Growth propagation from right side.  */
5887             p->balance++;
5888           else if (p->balance > 0)
5889             {
5890               if (r->balance > 0)
5891                 {
5892                   /* R rotation.  */
5893                   p->right = r->left;
5894                   if (p->right)
5895                     p->right->parent = p;
5896                   r->left = p;
5897
5898                   p->balance = 0;
5899                   r->balance = 0;
5900
5901                   s = p->parent;
5902                   p->parent = r;
5903                   r->parent = s;
5904                   if (s)
5905                     {
5906                       if (s->left == p)
5907                         s->left = r;
5908                       else
5909                         s->right = r;
5910                     }
5911                   else
5912                     constructor_pending_elts = r;
5913                 }
5914               else /* r->balance == -1 */
5915                 {
5916                   /* RL rotation */
5917                   struct init_node *t = r->left;
5918
5919                   r->left = t->right;
5920                   if (r->left)
5921                     r->left->parent = r;
5922                   t->right = r;
5923
5924                   p->right = t->left;
5925                   if (p->right)
5926                     p->right->parent = p;
5927                   t->left = p;
5928
5929                   r->balance = (t->balance < 0);
5930                   p->balance = -(t->balance > 0);
5931                   t->balance = 0;
5932
5933                   s = p->parent;
5934                   p->parent = t;
5935                   r->parent = t;
5936                   t->parent = s;
5937                   if (s)
5938                     {
5939                       if (s->left == p)
5940                         s->left = t;
5941                       else
5942                         s->right = t;
5943                     }
5944                   else
5945                     constructor_pending_elts = t;
5946                 }
5947               break;
5948             }
5949           else
5950             {
5951               /* p->balance == -1; growth of right side balances the node.  */
5952               p->balance = 0;
5953               break;
5954             }
5955         }
5956
5957       r = p;
5958       p = p->parent;
5959     }
5960 }
5961
5962 /* Build AVL tree from a sorted chain.  */
5963
5964 static void
5965 set_nonincremental_init ()
5966 {
5967   tree chain;
5968
5969   if (TREE_CODE (constructor_type) != RECORD_TYPE
5970       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5971     return;
5972
5973   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5974     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5975   constructor_elements = 0;
5976   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5977     {
5978       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5979       /* Skip any nameless bit fields at the beginning.  */
5980       while (constructor_unfilled_fields != 0
5981              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5982              && DECL_NAME (constructor_unfilled_fields) == 0)
5983         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5984
5985     }
5986   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5987     {
5988       if (TYPE_DOMAIN (constructor_type))
5989         constructor_unfilled_index
5990             = convert (bitsizetype,
5991                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5992       else
5993         constructor_unfilled_index = bitsize_zero_node;
5994     }
5995   constructor_incremental = 0;
5996 }
5997
5998 /* Build AVL tree from a string constant.  */
5999
6000 static void
6001 set_nonincremental_init_from_string (str)
6002      tree str;
6003 {
6004   tree value, purpose, type;
6005   HOST_WIDE_INT val[2];
6006   const char *p, *end;
6007   int byte, wchar_bytes, charwidth, bitpos;
6008
6009   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6010     abort ();
6011
6012   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6013       == TYPE_PRECISION (char_type_node))
6014     wchar_bytes = 1;
6015   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6016            == TYPE_PRECISION (wchar_type_node))
6017     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6018   else
6019     abort ();
6020
6021   charwidth = TYPE_PRECISION (char_type_node);
6022   type = TREE_TYPE (constructor_type);
6023   p = TREE_STRING_POINTER (str);
6024   end = p + TREE_STRING_LENGTH (str);
6025
6026   for (purpose = bitsize_zero_node;
6027        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6028        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6029     {
6030       if (wchar_bytes == 1)
6031         {
6032           val[1] = (unsigned char) *p++;
6033           val[0] = 0;
6034         }
6035       else
6036         {
6037           val[0] = 0;
6038           val[1] = 0;
6039           for (byte = 0; byte < wchar_bytes; byte++)
6040             {
6041               if (BYTES_BIG_ENDIAN)
6042                 bitpos = (wchar_bytes - byte - 1) * charwidth;
6043               else
6044                 bitpos = byte * charwidth;
6045               val[bitpos < HOST_BITS_PER_WIDE_INT]
6046                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6047                    << (bitpos % HOST_BITS_PER_WIDE_INT);
6048             }
6049         }
6050
6051       if (!TREE_UNSIGNED (type))
6052         {
6053           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6054           if (bitpos < HOST_BITS_PER_WIDE_INT)
6055             {
6056               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6057                 {
6058                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6059                   val[0] = -1;
6060                 }
6061             }
6062           else if (bitpos == HOST_BITS_PER_WIDE_INT)
6063             {
6064               if (val[1] < 0)
6065                 val[0] = -1;
6066             }
6067           else if (val[0] & (((HOST_WIDE_INT) 1)
6068                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6069             val[0] |= ((HOST_WIDE_INT) -1)
6070                       << (bitpos - HOST_BITS_PER_WIDE_INT);
6071         }
6072
6073       value = build_int_2 (val[1], val[0]);
6074       TREE_TYPE (value) = type;
6075       add_pending_init (purpose, value);
6076     }
6077
6078   constructor_incremental = 0;
6079 }
6080
6081 /* Return value of FIELD in pending initializer or zero if the field was
6082    not initialized yet.  */
6083
6084 static tree
6085 find_init_member (field)
6086      tree field;
6087 {
6088   struct init_node *p;
6089
6090   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6091     {
6092       if (constructor_incremental
6093           && tree_int_cst_lt (field, constructor_unfilled_index))
6094         set_nonincremental_init ();
6095
6096       p = constructor_pending_elts;
6097       while (p)
6098         {
6099           if (tree_int_cst_lt (field, p->purpose))
6100             p = p->left;
6101           else if (tree_int_cst_lt (p->purpose, field))
6102             p = p->right;
6103           else
6104             return p->value;
6105         }
6106     }
6107   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6108     {
6109       tree bitpos = bit_position (field);
6110
6111       if (constructor_incremental
6112           && (!constructor_unfilled_fields
6113               || tree_int_cst_lt (bitpos,
6114                                   bit_position (constructor_unfilled_fields))))
6115         set_nonincremental_init ();
6116
6117       p = constructor_pending_elts;
6118       while (p)
6119         {
6120           if (field == p->purpose)
6121             return p->value;
6122           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6123             p = p->left;
6124           else
6125             p = p->right;
6126         }
6127     }
6128   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6129     {
6130       if (constructor_elements
6131           && TREE_PURPOSE (constructor_elements) == field)
6132         return TREE_VALUE (constructor_elements);
6133     }
6134   return 0;
6135 }
6136
6137 /* "Output" the next constructor element.
6138    At top level, really output it to assembler code now.
6139    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6140    TYPE is the data type that the containing data type wants here.
6141    FIELD is the field (a FIELD_DECL) or the index that this element fills.
6142
6143    PENDING if non-nil means output pending elements that belong
6144    right after this element.  (PENDING is normally 1;
6145    it is 0 while outputting pending elements, to avoid recursion.)  */
6146
6147 static void
6148 output_init_element (value, type, field, pending)
6149      tree value, type, field;
6150      int pending;
6151 {
6152   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6153       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6154           && !(TREE_CODE (value) == STRING_CST
6155                && TREE_CODE (type) == ARRAY_TYPE
6156                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6157           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6158                          TYPE_MAIN_VARIANT (type))))
6159     value = default_conversion (value);
6160
6161   if (value == error_mark_node)
6162     constructor_erroneous = 1;
6163   else if (!TREE_CONSTANT (value))
6164     constructor_constant = 0;
6165   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6166            || ((TREE_CODE (constructor_type) == RECORD_TYPE
6167                 || TREE_CODE (constructor_type) == UNION_TYPE)
6168                && DECL_C_BIT_FIELD (field)
6169                && TREE_CODE (value) != INTEGER_CST))
6170     constructor_simple = 0;
6171
6172   if (require_constant_value && ! TREE_CONSTANT (value))
6173     {
6174       error_init ("initializer element is not constant");
6175       value = error_mark_node;
6176     }
6177   else if (require_constant_elements
6178            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6179     pedwarn ("initializer element is not computable at load time");
6180
6181   /* If this field is empty (and not at the end of structure),
6182      don't do anything other than checking the initializer.  */
6183   if (field
6184       && (TREE_TYPE (field) == error_mark_node
6185           || (COMPLETE_TYPE_P (TREE_TYPE (field))
6186               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6187               && (TREE_CODE (constructor_type) == ARRAY_TYPE
6188                   || TREE_CHAIN (field)))))
6189     return;
6190
6191   if (value == error_mark_node)
6192     {
6193       constructor_erroneous = 1;
6194       return;
6195     }
6196
6197   /* If this element doesn't come next in sequence,
6198      put it on constructor_pending_elts.  */
6199   if (TREE_CODE (constructor_type) == ARRAY_TYPE
6200       && (!constructor_incremental
6201           || !tree_int_cst_equal (field, constructor_unfilled_index)))
6202     {
6203       if (constructor_incremental
6204           && tree_int_cst_lt (field, constructor_unfilled_index))
6205         set_nonincremental_init ();
6206
6207       add_pending_init (field,
6208                         digest_init (type, value, require_constant_value,
6209                                      require_constant_elements));
6210       return;
6211     }
6212   else if (TREE_CODE (constructor_type) == RECORD_TYPE
6213            && (!constructor_incremental
6214                || field != constructor_unfilled_fields))
6215     {
6216       /* We do this for records but not for unions.  In a union,
6217          no matter which field is specified, it can be initialized
6218          right away since it starts at the beginning of the union.  */
6219       if (constructor_incremental)
6220         {
6221           if (!constructor_unfilled_fields)
6222             set_nonincremental_init ();
6223           else
6224             {
6225               tree bitpos, unfillpos;
6226
6227               bitpos = bit_position (field);
6228               unfillpos = bit_position (constructor_unfilled_fields);
6229
6230               if (tree_int_cst_lt (bitpos, unfillpos))
6231                 set_nonincremental_init ();
6232             }
6233         }
6234
6235       add_pending_init (field,
6236                         digest_init (type, value, require_constant_value,
6237                                      require_constant_elements));
6238       return;
6239     }
6240   else if (TREE_CODE (constructor_type) == UNION_TYPE
6241            && constructor_elements)
6242     {
6243       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6244         warning_init ("initialized field with side-effects overwritten");
6245
6246       /* We can have just one union field set.  */
6247       constructor_elements = 0;
6248     }
6249
6250   /* Otherwise, output this element either to
6251      constructor_elements or to the assembler file.  */
6252
6253   if (field && TREE_CODE (field) == INTEGER_CST)
6254     field = copy_node (field);
6255   constructor_elements
6256     = tree_cons (field, digest_init (type, value,
6257                                      require_constant_value,
6258                                      require_constant_elements),
6259                  constructor_elements);
6260
6261   /* Advance the variable that indicates sequential elements output.  */
6262   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6263     constructor_unfilled_index
6264       = size_binop (PLUS_EXPR, constructor_unfilled_index,
6265                     bitsize_one_node);
6266   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6267     {
6268       constructor_unfilled_fields
6269         = TREE_CHAIN (constructor_unfilled_fields);
6270
6271       /* Skip any nameless bit fields.  */
6272       while (constructor_unfilled_fields != 0
6273              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6274              && DECL_NAME (constructor_unfilled_fields) == 0)
6275         constructor_unfilled_fields =
6276           TREE_CHAIN (constructor_unfilled_fields);
6277     }
6278   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6279     constructor_unfilled_fields = 0;
6280
6281   /* Now output any pending elements which have become next.  */
6282   if (pending)
6283     output_pending_init_elements (0);
6284 }
6285
6286 /* Output any pending elements which have become next.
6287    As we output elements, constructor_unfilled_{fields,index}
6288    advances, which may cause other elements to become next;
6289    if so, they too are output.
6290
6291    If ALL is 0, we return when there are
6292    no more pending elements to output now.
6293
6294    If ALL is 1, we output space as necessary so that
6295    we can output all the pending elements.  */
6296
6297 static void
6298 output_pending_init_elements (all)
6299      int all;
6300 {
6301   struct init_node *elt = constructor_pending_elts;
6302   tree next;
6303
6304  retry:
6305
6306   /* Look thru the whole pending tree.
6307      If we find an element that should be output now,
6308      output it.  Otherwise, set NEXT to the element
6309      that comes first among those still pending.  */
6310
6311   next = 0;
6312   while (elt)
6313     {
6314       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6315         {
6316           if (tree_int_cst_equal (elt->purpose,
6317                                   constructor_unfilled_index))
6318             output_init_element (elt->value,
6319                                  TREE_TYPE (constructor_type),
6320                                  constructor_unfilled_index, 0);
6321           else if (tree_int_cst_lt (constructor_unfilled_index,
6322                                     elt->purpose))
6323             {
6324               /* Advance to the next smaller node.  */
6325               if (elt->left)
6326                 elt = elt->left;
6327               else
6328                 {
6329                   /* We have reached the smallest node bigger than the
6330                      current unfilled index.  Fill the space first.  */
6331                   next = elt->purpose;
6332                   break;
6333                 }
6334             }
6335           else
6336             {
6337               /* Advance to the next bigger node.  */
6338               if (elt->right)
6339                 elt = elt->right;
6340               else
6341                 {
6342                   /* We have reached the biggest node in a subtree.  Find
6343                      the parent of it, which is the next bigger node.  */
6344                   while (elt->parent && elt->parent->right == elt)
6345                     elt = elt->parent;
6346                   elt = elt->parent;
6347                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6348                                               elt->purpose))
6349                     {
6350                       next = elt->purpose;
6351                       break;
6352                     }
6353                 }
6354             }
6355         }
6356       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6357                || TREE_CODE (constructor_type) == UNION_TYPE)
6358         {
6359           tree ctor_unfilled_bitpos, elt_bitpos;
6360
6361           /* If the current record is complete we are done.  */
6362           if (constructor_unfilled_fields == 0)
6363             break;
6364
6365           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6366           elt_bitpos = bit_position (elt->purpose);
6367           /* We can't compare fields here because there might be empty
6368              fields in between.  */
6369           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6370             {
6371               constructor_unfilled_fields = elt->purpose;
6372               output_init_element (elt->value, TREE_TYPE (elt->purpose),
6373                                    elt->purpose, 0);
6374             }
6375           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6376             {
6377               /* Advance to the next smaller node.  */
6378               if (elt->left)
6379                 elt = elt->left;
6380               else
6381                 {
6382                   /* We have reached the smallest node bigger than the
6383                      current unfilled field.  Fill the space first.  */
6384                   next = elt->purpose;
6385                   break;
6386                 }
6387             }
6388           else
6389             {
6390               /* Advance to the next bigger node.  */
6391               if (elt->right)
6392                 elt = elt->right;
6393               else
6394                 {
6395                   /* We have reached the biggest node in a subtree.  Find
6396                      the parent of it, which is the next bigger node.  */
6397                   while (elt->parent && elt->parent->right == elt)
6398                     elt = elt->parent;
6399                   elt = elt->parent;
6400                   if (elt
6401                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
6402                                            bit_position (elt->purpose))))
6403                     {
6404                       next = elt->purpose;
6405                       break;
6406                     }
6407                 }
6408             }
6409         }
6410     }
6411
6412   /* Ordinarily return, but not if we want to output all
6413      and there are elements left.  */
6414   if (! (all && next != 0))
6415     return;
6416
6417   /* If it's not incremental, just skip over the gap, so that after
6418      jumping to retry we will output the next successive element.  */
6419   if (TREE_CODE (constructor_type) == RECORD_TYPE
6420       || TREE_CODE (constructor_type) == UNION_TYPE)
6421     constructor_unfilled_fields = next;
6422   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6423     constructor_unfilled_index = next;
6424
6425   /* ELT now points to the node in the pending tree with the next
6426      initializer to output.  */
6427   goto retry;
6428 }
6429 \f
6430 /* Add one non-braced element to the current constructor level.
6431    This adjusts the current position within the constructor's type.
6432    This may also start or terminate implicit levels
6433    to handle a partly-braced initializer.
6434
6435    Once this has found the correct level for the new element,
6436    it calls output_init_element.  */
6437
6438 void
6439 process_init_element (value)
6440      tree value;
6441 {
6442   tree orig_value = value;
6443   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6444
6445   designator_depth = 0;
6446   designator_errorneous = 0;
6447
6448   /* Handle superfluous braces around string cst as in
6449      char x[] = {"foo"}; */
6450   if (string_flag
6451       && constructor_type
6452       && TREE_CODE (constructor_type) == ARRAY_TYPE
6453       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6454       && integer_zerop (constructor_unfilled_index))
6455     {
6456       if (constructor_stack->replacement_value)
6457         error_init ("excess elements in char array initializer");
6458       constructor_stack->replacement_value = value;
6459       return;
6460     }
6461
6462   if (constructor_stack->replacement_value != 0)
6463     {
6464       error_init ("excess elements in struct initializer");
6465       return;
6466     }
6467
6468   /* Ignore elements of a brace group if it is entirely superfluous
6469      and has already been diagnosed.  */
6470   if (constructor_type == 0)
6471     return;
6472
6473   /* If we've exhausted any levels that didn't have braces,
6474      pop them now.  */
6475   while (constructor_stack->implicit)
6476     {
6477       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6478            || TREE_CODE (constructor_type) == UNION_TYPE)
6479           && constructor_fields == 0)
6480         process_init_element (pop_init_level (1));
6481       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6482                && (constructor_max_index == 0
6483                    || tree_int_cst_lt (constructor_max_index,
6484                                        constructor_index)))
6485         process_init_element (pop_init_level (1));
6486       else
6487         break;
6488     }
6489
6490   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
6491   if (constructor_range_stack)
6492     value = save_expr (value);
6493
6494   while (1)
6495     {
6496       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6497         {
6498           tree fieldtype;
6499           enum tree_code fieldcode;
6500
6501           if (constructor_fields == 0)
6502             {
6503               pedwarn_init ("excess elements in struct initializer");
6504               break;
6505             }
6506
6507           fieldtype = TREE_TYPE (constructor_fields);
6508           if (fieldtype != error_mark_node)
6509             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6510           fieldcode = TREE_CODE (fieldtype);
6511
6512           /* Accept a string constant to initialize a subarray.  */
6513           if (value != 0
6514               && fieldcode == ARRAY_TYPE
6515               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6516               && string_flag)
6517             value = orig_value;
6518           /* Otherwise, if we have come to a subaggregate,
6519              and we don't have an element of its type, push into it.  */
6520           else if (value != 0 && !constructor_no_implicit
6521                    && value != error_mark_node
6522                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6523                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6524                        || fieldcode == UNION_TYPE))
6525             {
6526               push_init_level (1);
6527               continue;
6528             }
6529
6530           if (value)
6531             {
6532               push_member_name (constructor_fields);
6533               output_init_element (value, fieldtype, constructor_fields, 1);
6534               RESTORE_SPELLING_DEPTH (constructor_depth);
6535             }
6536           else
6537             /* Do the bookkeeping for an element that was
6538                directly output as a constructor.  */
6539             {
6540               /* For a record, keep track of end position of last field.  */
6541               if (DECL_SIZE (constructor_fields))
6542                 constructor_bit_index
6543                   = size_binop (PLUS_EXPR,
6544                                 bit_position (constructor_fields),
6545                                 DECL_SIZE (constructor_fields));
6546
6547               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6548               /* Skip any nameless bit fields.  */
6549               while (constructor_unfilled_fields != 0
6550                      && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6551                      && DECL_NAME (constructor_unfilled_fields) == 0)
6552                 constructor_unfilled_fields =
6553                   TREE_CHAIN (constructor_unfilled_fields);
6554             }
6555
6556           constructor_fields = TREE_CHAIN (constructor_fields);
6557           /* Skip any nameless bit fields at the beginning.  */
6558           while (constructor_fields != 0
6559                  && DECL_C_BIT_FIELD (constructor_fields)
6560                  && DECL_NAME (constructor_fields) == 0)
6561             constructor_fields = TREE_CHAIN (constructor_fields);
6562         }
6563       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6564         {
6565           tree fieldtype;
6566           enum tree_code fieldcode;
6567
6568           if (constructor_fields == 0)
6569             {
6570               pedwarn_init ("excess elements in union initializer");
6571               break;
6572             }
6573
6574           fieldtype = TREE_TYPE (constructor_fields);
6575           if (fieldtype != error_mark_node)
6576             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6577           fieldcode = TREE_CODE (fieldtype);
6578
6579           /* Warn that traditional C rejects initialization of unions.
6580              We skip the warning if the value is zero.  This is done
6581              under the assumption that the zero initializer in user
6582              code appears conditioned on e.g. __STDC__ to avoid
6583              "missing initializer" warnings and relies on default
6584              initialization to zero in the traditional C case.  */
6585           if (warn_traditional && !in_system_header
6586               && !(value && (integer_zerop (value) || real_zerop (value))))
6587             warning ("traditional C rejects initialization of unions");
6588
6589           /* Accept a string constant to initialize a subarray.  */
6590           if (value != 0
6591               && fieldcode == ARRAY_TYPE
6592               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6593               && string_flag)
6594             value = orig_value;
6595           /* Otherwise, if we have come to a subaggregate,
6596              and we don't have an element of its type, push into it.  */
6597           else if (value != 0 && !constructor_no_implicit
6598                    && value != error_mark_node
6599                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6600                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6601                        || fieldcode == UNION_TYPE))
6602             {
6603               push_init_level (1);
6604               continue;
6605             }
6606
6607           if (value)
6608             {
6609               push_member_name (constructor_fields);
6610               output_init_element (value, fieldtype, constructor_fields, 1);
6611               RESTORE_SPELLING_DEPTH (constructor_depth);
6612             }
6613           else
6614             /* Do the bookkeeping for an element that was
6615                directly output as a constructor.  */
6616             {
6617               constructor_bit_index = DECL_SIZE (constructor_fields);
6618               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6619             }
6620
6621           constructor_fields = 0;
6622         }
6623       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6624         {
6625           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6626           enum tree_code eltcode = TREE_CODE (elttype);
6627
6628           /* Accept a string constant to initialize a subarray.  */
6629           if (value != 0
6630               && eltcode == ARRAY_TYPE
6631               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6632               && string_flag)
6633             value = orig_value;
6634           /* Otherwise, if we have come to a subaggregate,
6635              and we don't have an element of its type, push into it.  */
6636           else if (value != 0 && !constructor_no_implicit
6637                    && value != error_mark_node
6638                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6639                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6640                        || eltcode == UNION_TYPE))
6641             {
6642               push_init_level (1);
6643               continue;
6644             }
6645
6646           if (constructor_max_index != 0
6647               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6648                   || integer_all_onesp (constructor_max_index)))
6649             {
6650               pedwarn_init ("excess elements in array initializer");
6651               break;
6652             }
6653
6654           /* Now output the actual element.  */
6655           if (value)
6656             {
6657               push_array_bounds (tree_low_cst (constructor_index, 0));
6658               output_init_element (value, elttype, constructor_index, 1);
6659               RESTORE_SPELLING_DEPTH (constructor_depth);
6660             }
6661
6662           constructor_index
6663             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6664
6665           if (! value)
6666             /* If we are doing the bookkeeping for an element that was
6667                directly output as a constructor, we must update
6668                constructor_unfilled_index.  */
6669             constructor_unfilled_index = constructor_index;
6670         }
6671
6672       /* Handle the sole element allowed in a braced initializer
6673          for a scalar variable.  */
6674       else if (constructor_fields == 0)
6675         {
6676           pedwarn_init ("excess elements in scalar initializer");
6677           break;
6678         }
6679       else
6680         {
6681           if (value)
6682             output_init_element (value, constructor_type, NULL_TREE, 1);
6683           constructor_fields = 0;
6684         }
6685
6686       /* Handle range initializers either at this level or anywhere higher
6687          in the designator stack.  */
6688       if (constructor_range_stack)
6689         {
6690           struct constructor_range_stack *p, *range_stack;
6691           int finish = 0;
6692
6693           range_stack = constructor_range_stack;
6694           constructor_range_stack = 0;
6695           while (constructor_stack != range_stack->stack)
6696             {
6697               if (!constructor_stack->implicit)
6698                 abort ();
6699               process_init_element (pop_init_level (1));
6700             }
6701           for (p = range_stack;
6702                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6703                p = p->prev)
6704             {
6705               if (!constructor_stack->implicit)
6706                 abort ();
6707               process_init_element (pop_init_level (1));
6708             }
6709
6710           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6711           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6712             finish = 1;
6713
6714           while (1)
6715             {
6716               constructor_index = p->index;
6717               constructor_fields = p->fields;
6718               if (finish && p->range_end && p->index == p->range_start)
6719                 {
6720                   finish = 0;
6721                   p->prev = 0;
6722                 }
6723               p = p->next;
6724               if (!p)
6725                 break;
6726               push_init_level (2);
6727               p->stack = constructor_stack;
6728               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6729                 p->index = p->range_start;
6730             }
6731
6732           if (!finish)
6733             constructor_range_stack = range_stack;
6734           continue;
6735         }
6736
6737       break;
6738     }
6739
6740   constructor_range_stack = 0;
6741 }
6742 \f
6743 /* Build a simple asm-statement, from one string literal.  */
6744 tree
6745 simple_asm_stmt (expr)
6746      tree expr;
6747 {
6748   STRIP_NOPS (expr);
6749
6750   if (TREE_CODE (expr) == ADDR_EXPR)
6751     expr = TREE_OPERAND (expr, 0);
6752
6753   if (TREE_CODE (expr) == STRING_CST)
6754     {
6755       tree stmt;
6756
6757       if (TREE_CHAIN (expr))
6758         expr = combine_strings (expr);
6759       stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6760                                    NULL_TREE, NULL_TREE,
6761                                    NULL_TREE));
6762       ASM_INPUT_P (stmt) = 1;
6763       return stmt;
6764     }
6765
6766   error ("argument of `asm' is not a constant string");
6767   return NULL_TREE;
6768 }
6769
6770 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6771    STRING, some OUTPUTS, some INPUTS, and some CLOBBERS.  */
6772
6773 tree
6774 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6775      tree cv_qualifier;
6776      tree string;
6777      tree outputs;
6778      tree inputs;
6779      tree clobbers;
6780 {
6781   tree tail;
6782
6783   if (TREE_CHAIN (string))
6784     string = combine_strings (string);
6785   if (TREE_CODE (string) != STRING_CST)
6786     {
6787       error ("asm template is not a string constant");
6788       return NULL_TREE;
6789     }
6790
6791   if (cv_qualifier != NULL_TREE
6792       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6793     {
6794       warning ("%s qualifier ignored on asm",
6795                IDENTIFIER_POINTER (cv_qualifier));
6796       cv_qualifier = NULL_TREE;
6797     }
6798
6799   /* We can remove output conversions that change the type,
6800      but not the mode.  */
6801   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6802     {
6803       tree output = TREE_VALUE (tail);
6804
6805       STRIP_NOPS (output);
6806       TREE_VALUE (tail) = output;
6807
6808       /* Allow conversions as LHS here.  build_modify_expr as called below
6809          will do the right thing with them.  */
6810       while (TREE_CODE (output) == NOP_EXPR
6811              || TREE_CODE (output) == CONVERT_EXPR
6812              || TREE_CODE (output) == FLOAT_EXPR
6813              || TREE_CODE (output) == FIX_TRUNC_EXPR
6814              || TREE_CODE (output) == FIX_FLOOR_EXPR
6815              || TREE_CODE (output) == FIX_ROUND_EXPR
6816              || TREE_CODE (output) == FIX_CEIL_EXPR)
6817         output = TREE_OPERAND (output, 0);
6818
6819       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6820     }
6821
6822   /* Remove output conversions that change the type but not the mode.  */
6823   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6824     {
6825       tree output = TREE_VALUE (tail);
6826       STRIP_NOPS (output);
6827       TREE_VALUE (tail) = output;
6828     }
6829
6830   /* Perform default conversions on array and function inputs.
6831      Don't do this for other types as it would screw up operands
6832      expected to be in memory.  */
6833   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6834     if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6835         || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6836       TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6837
6838   return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6839                                outputs, inputs, clobbers));
6840 }
6841
6842 /* Expand an ASM statement with operands, handling output operands
6843    that are not variables or INDIRECT_REFS by transforming such
6844    cases into cases that expand_asm_operands can handle.
6845
6846    Arguments are same as for expand_asm_operands.  */
6847
6848 void
6849 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6850      tree string, outputs, inputs, clobbers;
6851      int vol;
6852      const char *filename;
6853      int line;
6854 {
6855   int noutputs = list_length (outputs);
6856   register int i;
6857   /* o[I] is the place that output number I should be written.  */
6858   register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6859   register tree tail;
6860
6861   /* Record the contents of OUTPUTS before it is modified.  */
6862   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6863     o[i] = TREE_VALUE (tail);
6864
6865   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6866      OUTPUTS some trees for where the values were actually stored.  */
6867   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6868
6869   /* Copy all the intermediate outputs into the specified outputs.  */
6870   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6871     {
6872       if (o[i] != TREE_VALUE (tail))
6873         {
6874           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6875                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6876           free_temp_slots ();
6877
6878           /* Restore the original value so that it's correct the next
6879              time we expand this function.  */
6880           TREE_VALUE (tail) = o[i];
6881         }
6882       /* Detect modification of read-only values.
6883          (Otherwise done by build_modify_expr.)  */
6884       else
6885         {
6886           tree type = TREE_TYPE (o[i]);
6887           if (TREE_READONLY (o[i])
6888               || TYPE_READONLY (type)
6889               || ((TREE_CODE (type) == RECORD_TYPE
6890                    || TREE_CODE (type) == UNION_TYPE)
6891                   && C_TYPE_FIELDS_READONLY (type)))
6892             readonly_warning (o[i], "modification by `asm'");
6893         }
6894     }
6895
6896   /* Those MODIFY_EXPRs could do autoincrements.  */
6897   emit_queue ();
6898 }
6899 \f
6900 /* Expand a C `return' statement.
6901    RETVAL is the expression for what to return,
6902    or a null pointer for `return;' with no value.  */
6903
6904 tree
6905 c_expand_return (retval)
6906      tree retval;
6907 {
6908   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6909
6910   if (TREE_THIS_VOLATILE (current_function_decl))
6911     warning ("function declared `noreturn' has a `return' statement");
6912
6913   if (!retval)
6914     {
6915       current_function_returns_null = 1;
6916       if ((warn_return_type || flag_isoc99)
6917           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6918         pedwarn_c99 ("`return' with no value, in function returning non-void");
6919     }
6920   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6921     {
6922       current_function_returns_null = 1;
6923       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6924         pedwarn ("`return' with a value, in function returning void");
6925     }
6926   else
6927     {
6928       tree t = convert_for_assignment (valtype, retval, _("return"),
6929                                        NULL_TREE, NULL_TREE, 0);
6930       tree res = DECL_RESULT (current_function_decl);
6931       tree inner;
6932
6933       if (t == error_mark_node)
6934         return NULL_TREE;
6935
6936       inner = t = convert (TREE_TYPE (res), t);
6937
6938       /* Strip any conversions, additions, and subtractions, and see if
6939          we are returning the address of a local variable.  Warn if so.  */
6940       while (1)
6941         {
6942           switch (TREE_CODE (inner))
6943             {
6944             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6945             case PLUS_EXPR:
6946               inner = TREE_OPERAND (inner, 0);
6947               continue;
6948
6949             case MINUS_EXPR:
6950               /* If the second operand of the MINUS_EXPR has a pointer
6951                  type (or is converted from it), this may be valid, so
6952                  don't give a warning.  */
6953               {
6954                 tree op1 = TREE_OPERAND (inner, 1);
6955
6956                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6957                        && (TREE_CODE (op1) == NOP_EXPR
6958                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6959                            || TREE_CODE (op1) == CONVERT_EXPR))
6960                   op1 = TREE_OPERAND (op1, 0);
6961
6962                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6963                   break;
6964
6965                 inner = TREE_OPERAND (inner, 0);
6966                 continue;
6967               }
6968
6969             case ADDR_EXPR:
6970               inner = TREE_OPERAND (inner, 0);
6971
6972               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6973                 inner = TREE_OPERAND (inner, 0);
6974
6975               if (TREE_CODE (inner) == VAR_DECL
6976                   && ! DECL_EXTERNAL (inner)
6977                   && ! TREE_STATIC (inner)
6978                   && DECL_CONTEXT (inner) == current_function_decl)
6979                 warning ("function returns address of local variable");
6980               break;
6981
6982             default:
6983               break;
6984             }
6985
6986           break;
6987         }
6988
6989       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6990       current_function_returns_value = 1;
6991     }
6992
6993  return add_stmt (build_return_stmt (retval));
6994 }
6995 \f
6996 struct c_switch {
6997   /* The SWITCH_STMT being built.  */
6998   tree switch_stmt;
6999   /* A splay-tree mapping the low element of a case range to the high
7000      element, or NULL_TREE if there is no high element.  Used to
7001      determine whether or not a new case label duplicates an old case
7002      label.  We need a tree, rather than simply a hash table, because
7003      of the GNU case range extension.  */
7004   splay_tree cases;
7005   /* The next node on the stack.  */
7006   struct c_switch *next;
7007 };
7008
7009 /* A stack of the currently active switch statements.  The innermost
7010    switch statement is on the top of the stack.  There is no need to
7011    mark the stack for garbage collection because it is only active
7012    during the processing of the body of a function, and we never
7013    collect at that point.  */
7014
7015 static struct c_switch *switch_stack;
7016
7017 /* Start a C switch statement, testing expression EXP.  Return the new
7018    SWITCH_STMT.  */
7019
7020 tree
7021 c_start_case (exp)
7022      tree exp;
7023 {
7024   register enum tree_code code;
7025   tree type;
7026   struct c_switch *cs;
7027
7028   if (exp != error_mark_node)
7029     {
7030       code = TREE_CODE (TREE_TYPE (exp));
7031       type = TREE_TYPE (exp);
7032
7033       if (! INTEGRAL_TYPE_P (type)
7034           && code != ERROR_MARK)
7035         {
7036           error ("switch quantity not an integer");
7037           exp = integer_zero_node;
7038         }
7039       else
7040         {
7041           tree index;
7042           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7043
7044           if (warn_traditional && !in_system_header
7045               && (type == long_integer_type_node
7046                   || type == long_unsigned_type_node))
7047             warning ("`long' switch expression not converted to `int' in ISO C");
7048
7049           exp = default_conversion (exp);
7050           type = TREE_TYPE (exp);
7051           index = get_unwidened (exp, NULL_TREE);
7052           /* We can't strip a conversion from a signed type to an
7053              unsigned, because if we did, int_fits_type_p would do the
7054              wrong thing when checking case values for being in range,
7055              and it's too hard to do the right thing.  */
7056           if (TREE_UNSIGNED (TREE_TYPE (exp))
7057               == TREE_UNSIGNED (TREE_TYPE (index)))
7058             exp = index;
7059         }
7060     }
7061
7062   /* Add this new SWITCH_STMT to the stack.  */
7063   cs = (struct c_switch *) xmalloc (sizeof (*cs));
7064   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE);
7065   cs->cases = splay_tree_new (case_compare, NULL, NULL);
7066   cs->next = switch_stack;
7067   switch_stack = cs;
7068
7069   return add_stmt (switch_stack->switch_stmt);
7070 }
7071
7072 /* Process a case label.  */
7073
7074 tree
7075 do_case (low_value, high_value)
7076      tree low_value;
7077      tree high_value;
7078 {
7079   tree label = NULL_TREE;
7080
7081   if (switch_stack)
7082     {
7083       label = c_add_case_label (switch_stack->cases,
7084                                 SWITCH_COND (switch_stack->switch_stmt),
7085                                 low_value, high_value);
7086       if (label == error_mark_node)
7087         label = NULL_TREE;
7088     }
7089   else if (low_value)
7090     error ("case label not within a switch statement");
7091   else
7092     error ("`default' label not within a switch statement");
7093
7094   return label;
7095 }
7096
7097 /* Finish the switch statement.  */
7098
7099 void
7100 c_finish_case ()
7101 {
7102   struct c_switch *cs = switch_stack;
7103
7104   RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7105
7106   /* Pop the stack.  */
7107   switch_stack = switch_stack->next;
7108   splay_tree_delete (cs->cases);
7109   free (cs);
7110 }