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