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 (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 (!noconvert)
2811             arg = default_conversion (arg);
2812         }
2813       else if (typecode != INTEGER_TYPE)
2814         {
2815           error ("wrong type argument to bit-complement");
2816           return error_mark_node;
2817         }
2818       else if (!noconvert)
2819         arg = default_conversion (arg);
2820       break;
2821
2822     case ABS_EXPR:
2823       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2824             || typecode == COMPLEX_TYPE))
2825         {
2826           error ("wrong type argument to abs");
2827           return error_mark_node;
2828         }
2829       else if (!noconvert)
2830         arg = default_conversion (arg);
2831       break;
2832
2833     case CONJ_EXPR:
2834       /* Conjugating a real value is a no-op, but allow it anyway.  */
2835       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2836             || typecode == COMPLEX_TYPE))
2837         {
2838           error ("wrong type argument to conjugation");
2839           return error_mark_node;
2840         }
2841       else if (!noconvert)
2842         arg = default_conversion (arg);
2843       break;
2844
2845     case TRUTH_NOT_EXPR:
2846       if (typecode != INTEGER_TYPE
2847           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2848           && typecode != COMPLEX_TYPE
2849           /* These will convert to a pointer.  */
2850           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2851         {
2852           error ("wrong type argument to unary exclamation mark");
2853           return error_mark_node;
2854         }
2855       arg = truthvalue_conversion (arg);
2856       return invert_truthvalue (arg);
2857
2858     case NOP_EXPR:
2859       break;
2860
2861     case REALPART_EXPR:
2862       if (TREE_CODE (arg) == COMPLEX_CST)
2863         return TREE_REALPART (arg);
2864       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2865         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2866       else
2867         return arg;
2868
2869     case IMAGPART_EXPR:
2870       if (TREE_CODE (arg) == COMPLEX_CST)
2871         return TREE_IMAGPART (arg);
2872       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2873         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2874       else
2875         return convert (TREE_TYPE (arg), integer_zero_node);
2876
2877     case PREINCREMENT_EXPR:
2878     case POSTINCREMENT_EXPR:
2879     case PREDECREMENT_EXPR:
2880     case POSTDECREMENT_EXPR:
2881       /* Handle complex lvalues (when permitted)
2882          by reduction to simpler cases.  */
2883
2884       val = unary_complex_lvalue (code, arg);
2885       if (val != 0)
2886         return val;
2887
2888       /* Increment or decrement the real part of the value,
2889          and don't change the imaginary part.  */
2890       if (typecode == COMPLEX_TYPE)
2891         {
2892           tree real, imag;
2893
2894           arg = stabilize_reference (arg);
2895           real = build_unary_op (REALPART_EXPR, arg, 1);
2896           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2897           return build (COMPLEX_EXPR, TREE_TYPE (arg),
2898                         build_unary_op (code, real, 1), imag);
2899         }
2900
2901       /* Report invalid types.  */
2902
2903       if (typecode != POINTER_TYPE
2904           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2905         {
2906           error ("wrong type argument to %s",
2907                  code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2908                  ? "increment" : "decrement");
2909           return error_mark_node;
2910         }
2911
2912       {
2913         register tree inc;
2914         tree result_type = TREE_TYPE (arg);
2915
2916         arg = get_unwidened (arg, 0);
2917         argtype = TREE_TYPE (arg);
2918
2919         /* Compute the increment.  */
2920
2921         if (typecode == POINTER_TYPE)
2922           {
2923             /* If pointer target is an undefined struct,
2924                we just cannot know how to do the arithmetic.  */
2925             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2926               error ("%s of pointer to unknown structure",
2927                      code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2928                      ? "increment" : "decrement");
2929             else if ((pedantic || warn_pointer_arith)
2930                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2931                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2932               pedwarn ("wrong type argument to %s",
2933                        code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2934                        ? "increment" : "decrement");
2935             inc = c_size_in_bytes (TREE_TYPE (result_type));
2936           }
2937         else
2938           inc = integer_one_node;
2939
2940         inc = convert (argtype, inc);
2941
2942         /* Handle incrementing a cast-expression.  */
2943
2944         while (1)
2945           switch (TREE_CODE (arg))
2946             {
2947             case NOP_EXPR:
2948             case CONVERT_EXPR:
2949             case FLOAT_EXPR:
2950             case FIX_TRUNC_EXPR:
2951             case FIX_FLOOR_EXPR:
2952             case FIX_ROUND_EXPR:
2953             case FIX_CEIL_EXPR:
2954               pedantic_lvalue_warning (CONVERT_EXPR);
2955               /* If the real type has the same machine representation
2956                  as the type it is cast to, we can make better output
2957                  by adding directly to the inside of the cast.  */
2958               if ((TREE_CODE (TREE_TYPE (arg))
2959                    == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2960                   && (TYPE_MODE (TREE_TYPE (arg))
2961                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2962                 arg = TREE_OPERAND (arg, 0);
2963               else
2964                 {
2965                   tree incremented, modify, value;
2966                   arg = stabilize_reference (arg);
2967                   if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2968                     value = arg;
2969                   else
2970                     value = save_expr (arg);
2971                   incremented = build (((code == PREINCREMENT_EXPR
2972                                          || code == POSTINCREMENT_EXPR)
2973                                         ? PLUS_EXPR : MINUS_EXPR),
2974                                        argtype, value, inc);
2975                   TREE_SIDE_EFFECTS (incremented) = 1;
2976                   modify = build_modify_expr (arg, NOP_EXPR, incremented);
2977                   value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2978                   TREE_USED (value) = 1;
2979                   return value;
2980                 }
2981               break;
2982
2983             default:
2984               goto give_up;
2985             }
2986       give_up:
2987
2988         /* Complain about anything else that is not a true lvalue.  */
2989         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2990                                     || code == POSTINCREMENT_EXPR)
2991                                    ? "invalid lvalue in increment"
2992                                    : "invalid lvalue in decrement")))
2993           return error_mark_node;
2994
2995         /* Report a read-only lvalue.  */
2996         if (TREE_READONLY (arg))
2997           readonly_warning (arg,
2998                             ((code == PREINCREMENT_EXPR
2999                               || code == POSTINCREMENT_EXPR)
3000                              ? "increment" : "decrement"));
3001
3002         val = build (code, TREE_TYPE (arg), arg, inc);
3003         TREE_SIDE_EFFECTS (val) = 1;
3004         val = convert (result_type, val);
3005         if (TREE_CODE (val) != code)
3006           TREE_NO_UNUSED_WARNING (val) = 1;
3007         return val;
3008       }
3009
3010     case ADDR_EXPR:
3011       /* Note that this operation never does default_conversion
3012          regardless of NOCONVERT.  */
3013
3014       /* Let &* cancel out to simplify resulting code.  */
3015       if (TREE_CODE (arg) == INDIRECT_REF)
3016         {
3017           /* Don't let this be an lvalue.  */
3018           if (lvalue_p (TREE_OPERAND (arg, 0)))
3019             return non_lvalue (TREE_OPERAND (arg, 0));
3020           return TREE_OPERAND (arg, 0);
3021         }
3022
3023       /* For &x[y], return x+y */
3024       if (TREE_CODE (arg) == ARRAY_REF)
3025         {
3026           if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3027             return error_mark_node;
3028           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3029                                   TREE_OPERAND (arg, 1), 1);
3030         }
3031
3032       /* Handle complex lvalues (when permitted)
3033          by reduction to simpler cases.  */
3034       val = unary_complex_lvalue (code, arg);
3035       if (val != 0)
3036         return val;
3037
3038 #if 0 /* Turned off because inconsistent;
3039          float f; *&(int)f = 3.4 stores in int format
3040          whereas (int)f = 3.4 stores in float format.  */
3041       /* Address of a cast is just a cast of the address
3042          of the operand of the cast.  */
3043       switch (TREE_CODE (arg))
3044         {
3045         case NOP_EXPR:
3046         case CONVERT_EXPR:
3047         case FLOAT_EXPR:
3048         case FIX_TRUNC_EXPR:
3049         case FIX_FLOOR_EXPR:
3050         case FIX_ROUND_EXPR:
3051         case FIX_CEIL_EXPR:
3052           if (pedantic)
3053             pedwarn ("ISO C forbids the address of a cast expression");
3054           return convert (build_pointer_type (TREE_TYPE (arg)),
3055                           build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3056                                           0));
3057         }
3058 #endif
3059
3060       /* Allow the address of a constructor if all the elements
3061          are constant.  */
3062       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3063         ;
3064       /* Anything not already handled and not a true memory reference
3065          is an error.  */
3066       else if (typecode != FUNCTION_TYPE
3067                && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3068         return error_mark_node;
3069
3070       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
3071       argtype = TREE_TYPE (arg);
3072
3073       /* If the lvalue is const or volatile, merge that into the type
3074          to which the address will point.  Note that you can't get a
3075          restricted pointer by taking the address of something, so we
3076          only have to deal with `const' and `volatile' here.  */
3077       if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3078           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3079           argtype = c_build_type_variant (argtype,
3080                                           TREE_READONLY (arg),
3081                                           TREE_THIS_VOLATILE (arg));
3082
3083       argtype = build_pointer_type (argtype);
3084
3085       if (mark_addressable (arg) == 0)
3086         return error_mark_node;
3087
3088       {
3089         tree addr;
3090
3091         if (TREE_CODE (arg) == COMPONENT_REF)
3092           {
3093             tree field = TREE_OPERAND (arg, 1);
3094
3095             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3096
3097             if (DECL_C_BIT_FIELD (field))
3098               {
3099                 error ("attempt to take address of bit-field structure member `%s'",
3100                        IDENTIFIER_POINTER (DECL_NAME (field)));
3101                 return error_mark_node;
3102               }
3103
3104             addr = fold (build (PLUS_EXPR, argtype,
3105                                 convert (argtype, addr),
3106                                 convert (argtype, byte_position (field))));
3107           }
3108         else
3109           addr = build1 (code, argtype, arg);
3110
3111         /* Address of a static or external variable or
3112            file-scope function counts as a constant.  */
3113         if (staticp (arg)
3114             && ! (TREE_CODE (arg) == FUNCTION_DECL
3115                   && DECL_CONTEXT (arg) != 0))
3116           TREE_CONSTANT (addr) = 1;
3117         return addr;
3118       }
3119
3120     default:
3121       break;
3122     }
3123
3124   if (argtype == 0)
3125     argtype = TREE_TYPE (arg);
3126   return fold (build1 (code, argtype, arg));
3127 }
3128
3129 #if 0
3130 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3131    convert ARG with the same conversions in the same order
3132    and return the result.  */
3133
3134 static tree
3135 convert_sequence (conversions, arg)
3136      tree conversions;
3137      tree arg;
3138 {
3139   switch (TREE_CODE (conversions))
3140     {
3141     case NOP_EXPR:
3142     case CONVERT_EXPR:
3143     case FLOAT_EXPR:
3144     case FIX_TRUNC_EXPR:
3145     case FIX_FLOOR_EXPR:
3146     case FIX_ROUND_EXPR:
3147     case FIX_CEIL_EXPR:
3148       return convert (TREE_TYPE (conversions),
3149                       convert_sequence (TREE_OPERAND (conversions, 0),
3150                                         arg));
3151
3152     default:
3153       return arg;
3154     }
3155 }
3156 #endif /* 0 */
3157
3158 /* Return nonzero if REF is an lvalue valid for this language.
3159    Lvalues can be assigned, unless their type has TYPE_READONLY.
3160    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
3161
3162 int
3163 lvalue_p (ref)
3164      tree ref;
3165 {
3166   register enum tree_code code = TREE_CODE (ref);
3167
3168   switch (code)
3169     {
3170     case REALPART_EXPR:
3171     case IMAGPART_EXPR:
3172     case COMPONENT_REF:
3173       return lvalue_p (TREE_OPERAND (ref, 0));
3174
3175     case STRING_CST:
3176       return 1;
3177
3178     case INDIRECT_REF:
3179     case ARRAY_REF:
3180     case VAR_DECL:
3181     case PARM_DECL:
3182     case RESULT_DECL:
3183     case ERROR_MARK:
3184       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3185               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3186
3187     case BIND_EXPR:
3188     case RTL_EXPR:
3189       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3190
3191     default:
3192       return 0;
3193     }
3194 }
3195
3196 /* Return nonzero if REF is an lvalue valid for this language;
3197    otherwise, print an error message and return zero.  */
3198
3199 int
3200 lvalue_or_else (ref, msgid)
3201      tree ref;
3202      const char *msgid;
3203 {
3204   int win = lvalue_p (ref);
3205
3206   if (! win)
3207     error ("%s", msgid);
3208
3209   return win;
3210 }
3211
3212 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3213    for certain kinds of expressions which are not really lvalues
3214    but which we can accept as lvalues.
3215
3216    If ARG is not a kind of expression we can handle, return zero.  */
3217
3218 static tree
3219 unary_complex_lvalue (code, arg)
3220      enum tree_code code;
3221      tree arg;
3222 {
3223   /* Handle (a, b) used as an "lvalue".  */
3224   if (TREE_CODE (arg) == COMPOUND_EXPR)
3225     {
3226       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3227
3228       /* If this returns a function type, it isn't really being used as
3229          an lvalue, so don't issue a warning about it.  */
3230       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3231         pedantic_lvalue_warning (COMPOUND_EXPR);
3232
3233       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3234                     TREE_OPERAND (arg, 0), real_result);
3235     }
3236
3237   /* Handle (a ? b : c) used as an "lvalue".  */
3238   if (TREE_CODE (arg) == COND_EXPR)
3239     {
3240       pedantic_lvalue_warning (COND_EXPR);
3241       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3242         pedantic_lvalue_warning (COMPOUND_EXPR);
3243
3244       return (build_conditional_expr
3245               (TREE_OPERAND (arg, 0),
3246                build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3247                build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3248     }
3249
3250   return 0;
3251 }
3252
3253 /* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
3254    COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
3255
3256 static void
3257 pedantic_lvalue_warning (code)
3258      enum tree_code code;
3259 {
3260   if (pedantic)
3261     switch (code)
3262       {
3263       case COND_EXPR:
3264         pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3265         break;
3266       case COMPOUND_EXPR:
3267         pedwarn ("ISO C forbids use of compound expressions as lvalues");
3268         break;
3269       default:
3270         pedwarn ("ISO C forbids use of cast expressions as lvalues");
3271         break;
3272       }
3273 }
3274 \f
3275 /* Warn about storing in something that is `const'.  */
3276
3277 void
3278 readonly_warning (arg, msgid)
3279      tree arg;
3280      const char *msgid;
3281 {
3282   if (TREE_CODE (arg) == COMPONENT_REF)
3283     {
3284       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3285         readonly_warning (TREE_OPERAND (arg, 0), msgid);
3286       else
3287         pedwarn ("%s of read-only member `%s'", _(msgid),
3288                  IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3289     }
3290   else if (TREE_CODE (arg) == VAR_DECL)
3291     pedwarn ("%s of read-only variable `%s'", _(msgid),
3292              IDENTIFIER_POINTER (DECL_NAME (arg)));
3293   else
3294     pedwarn ("%s of read-only location", _(msgid));
3295 }
3296 \f
3297 /* Mark EXP saying that we need to be able to take the
3298    address of it; it should not be allocated in a register.
3299    Value is 1 if successful.  */
3300
3301 int
3302 mark_addressable (exp)
3303      tree exp;
3304 {
3305   register tree x = exp;
3306   while (1)
3307     switch (TREE_CODE (x))
3308       {
3309       case COMPONENT_REF:
3310         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3311           {
3312             error ("cannot take address of bitfield `%s'",
3313                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3314             return 0;
3315           }
3316
3317         /* ... fall through ...  */
3318
3319       case ADDR_EXPR:
3320       case ARRAY_REF:
3321       case REALPART_EXPR:
3322       case IMAGPART_EXPR:
3323         x = TREE_OPERAND (x, 0);
3324         break;
3325
3326       case CONSTRUCTOR:
3327         TREE_ADDRESSABLE (x) = 1;
3328         return 1;
3329
3330       case VAR_DECL:
3331       case CONST_DECL:
3332       case PARM_DECL:
3333       case RESULT_DECL:
3334         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3335             && DECL_NONLOCAL (x))
3336           {
3337             if (TREE_PUBLIC (x))
3338               {
3339                 error ("global register variable `%s' used in nested function",
3340                        IDENTIFIER_POINTER (DECL_NAME (x)));
3341                 return 0;
3342               }
3343             pedwarn ("register variable `%s' used in nested function",
3344                      IDENTIFIER_POINTER (DECL_NAME (x)));
3345           }
3346         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3347           {
3348             if (TREE_PUBLIC (x))
3349               {
3350                 error ("address of global register variable `%s' requested",
3351                        IDENTIFIER_POINTER (DECL_NAME (x)));
3352                 return 0;
3353               }
3354
3355             /* If we are making this addressable due to its having
3356                volatile components, give a different error message.  Also
3357                handle the case of an unnamed parameter by not trying
3358                to give the name.  */
3359
3360             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3361               {
3362                 error ("cannot put object with volatile field into register");
3363                 return 0;
3364               }
3365
3366             pedwarn ("address of register variable `%s' requested",
3367                      IDENTIFIER_POINTER (DECL_NAME (x)));
3368           }
3369         put_var_into_stack (x);
3370
3371         /* drops in */
3372       case FUNCTION_DECL:
3373         TREE_ADDRESSABLE (x) = 1;
3374 #if 0  /* poplevel deals with this now.  */
3375         if (DECL_CONTEXT (x) == 0)
3376           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3377 #endif
3378
3379       default:
3380         return 1;
3381     }
3382 }
3383 \f
3384 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
3385
3386 tree
3387 build_conditional_expr (ifexp, op1, op2)
3388      tree ifexp, op1, op2;
3389 {
3390   register tree type1;
3391   register tree type2;
3392   register enum tree_code code1;
3393   register enum tree_code code2;
3394   register tree result_type = NULL;
3395   tree orig_op1 = op1, orig_op2 = op2;
3396
3397   ifexp = truthvalue_conversion (default_conversion (ifexp));
3398
3399 #if 0 /* Produces wrong result if within sizeof.  */
3400   /* Don't promote the operands separately if they promote
3401      the same way.  Return the unpromoted type and let the combined
3402      value get promoted if necessary.  */
3403
3404   if (TREE_TYPE (op1) == TREE_TYPE (op2)
3405       && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3406       && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3407       && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3408     {
3409       if (TREE_CODE (ifexp) == INTEGER_CST)
3410         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3411
3412       return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3413     }
3414 #endif
3415
3416   /* Promote both alternatives.  */
3417
3418   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3419     op1 = default_conversion (op1);
3420   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3421     op2 = default_conversion (op2);
3422
3423   if (TREE_CODE (ifexp) == ERROR_MARK
3424       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3425       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3426     return error_mark_node;
3427
3428   type1 = TREE_TYPE (op1);
3429   code1 = TREE_CODE (type1);
3430   type2 = TREE_TYPE (op2);
3431   code2 = TREE_CODE (type2);
3432
3433   /* Quickly detect the usual case where op1 and op2 have the same type
3434      after promotion.  */
3435   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3436     {
3437       if (type1 == type2)
3438         result_type = type1;
3439       else
3440         result_type = TYPE_MAIN_VARIANT (type1);
3441     }
3442   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3443             || code1 == COMPLEX_TYPE)
3444            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3445                || code2 == COMPLEX_TYPE))
3446     {
3447       result_type = common_type (type1, type2);
3448
3449       /* If -Wsign-compare, warn here if type1 and type2 have
3450          different signedness.  We'll promote the signed to unsigned
3451          and later code won't know it used to be different.
3452          Do this check on the original types, so that explicit casts
3453          will be considered, but default promotions won't.  */
3454       if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3455           && !skip_evaluation)
3456         {
3457           int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3458           int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3459
3460           if (unsigned_op1 ^ unsigned_op2)
3461             {
3462               /* Do not warn if the result type is signed, since the
3463                  signed type will only be chosen if it can represent
3464                  all the values of the unsigned type.  */
3465               if (! TREE_UNSIGNED (result_type))
3466                 /* OK */;
3467               /* Do not warn if the signed quantity is an unsuffixed
3468                  integer literal (or some static constant expression
3469                  involving such literals) and it is non-negative.  */
3470               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3471                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3472                 /* OK */;
3473               else
3474                 warning ("signed and unsigned type in conditional expression");
3475             }
3476         }
3477     }
3478   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3479     {
3480       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3481         pedwarn ("ISO C forbids conditional expr with only one void side");
3482       result_type = void_type_node;
3483     }
3484   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3485     {
3486       if (comp_target_types (type1, type2))
3487         result_type = common_type (type1, type2);
3488       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3489                && TREE_CODE (orig_op1) != NOP_EXPR)
3490         result_type = qualify_type (type2, type1);
3491       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3492                && TREE_CODE (orig_op2) != NOP_EXPR)
3493         result_type = qualify_type (type1, type2);
3494       else if (VOID_TYPE_P (TREE_TYPE (type1)))
3495         {
3496           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3497             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3498           result_type = qualify_type (type1, type2);
3499         }
3500       else if (VOID_TYPE_P (TREE_TYPE (type2)))
3501         {
3502           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3503             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3504           result_type = qualify_type (type2, type1);
3505         }
3506       else
3507         {
3508           pedwarn ("pointer type mismatch in conditional expression");
3509           result_type = build_pointer_type (void_type_node);
3510         }
3511     }
3512   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3513     {
3514       if (! integer_zerop (op2))
3515         pedwarn ("pointer/integer type mismatch in conditional expression");
3516       else
3517         {
3518           op2 = null_pointer_node;
3519 #if 0  /* The spec seems to say this is permitted.  */
3520           if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
3521             pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3522 #endif
3523         }
3524       result_type = type1;
3525     }
3526   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3527     {
3528       if (!integer_zerop (op1))
3529         pedwarn ("pointer/integer type mismatch in conditional expression");
3530       else
3531         {
3532           op1 = null_pointer_node;
3533 #if 0  /* The spec seems to say this is permitted.  */
3534           if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
3535             pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3536 #endif
3537         }
3538       result_type = type2;
3539     }
3540
3541   if (!result_type)
3542     {
3543       if (flag_cond_mismatch)
3544         result_type = void_type_node;
3545       else
3546         {
3547           error ("type mismatch in conditional expression");
3548           return error_mark_node;
3549         }
3550     }
3551
3552   /* Merge const and volatile flags of the incoming types.  */
3553   result_type
3554     = build_type_variant (result_type,
3555                           TREE_READONLY (op1) || TREE_READONLY (op2),
3556                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3557
3558   if (result_type != TREE_TYPE (op1))
3559     op1 = convert_and_check (result_type, op1);
3560   if (result_type != TREE_TYPE (op2))
3561     op2 = convert_and_check (result_type, op2);
3562
3563   if (TREE_CODE (ifexp) == INTEGER_CST)
3564     return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3565
3566   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3567 }
3568 \f
3569 /* Given a list of expressions, return a compound expression
3570    that performs them all and returns the value of the last of them.  */
3571
3572 tree
3573 build_compound_expr (list)
3574      tree list;
3575 {
3576   return internal_build_compound_expr (list, TRUE);
3577 }
3578
3579 static tree
3580 internal_build_compound_expr (list, first_p)
3581      tree list;
3582      int first_p;
3583 {
3584   register tree rest;
3585
3586   if (TREE_CHAIN (list) == 0)
3587     {
3588 #if 0 /* If something inside inhibited lvalueness, we should not override.  */
3589       /* Consider (x, y+0), which is not an lvalue since y+0 is not.  */
3590
3591       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3592       if (TREE_CODE (list) == NON_LVALUE_EXPR)
3593         list = TREE_OPERAND (list, 0);
3594 #endif
3595
3596       /* Don't let (0, 0) be null pointer constant.  */
3597       if (!first_p && integer_zerop (TREE_VALUE (list)))
3598         return non_lvalue (TREE_VALUE (list));
3599       return TREE_VALUE (list);
3600     }
3601
3602   if (TREE_CHAIN (list) != 0 && TREE_CHAIN (TREE_CHAIN (list)) == 0)
3603     {
3604       /* Convert arrays to pointers when there really is a comma operator.  */
3605       if (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (list)))) == ARRAY_TYPE)
3606         TREE_VALUE (TREE_CHAIN (list))
3607           = default_conversion (TREE_VALUE (TREE_CHAIN (list)));
3608     }
3609
3610   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3611
3612   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3613     {
3614       /* The left-hand operand of a comma expression is like an expression
3615          statement: with -W or -Wunused, we should warn if it doesn't have
3616          any side-effects, unless it was explicitly cast to (void).  */
3617       if ((extra_warnings || warn_unused_value)
3618            && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3619                 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3620         warning ("left-hand operand of comma expression has no effect");
3621
3622       /* When pedantic, a compound expression can be neither an lvalue
3623          nor an integer constant expression.  */
3624       if (! pedantic)
3625         return rest;
3626     }
3627
3628   /* With -Wunused, we should also warn if the left-hand operand does have
3629      side-effects, but computes a value which is not used.  For example, in
3630      `foo() + bar(), baz()' the result of the `+' operator is not used,
3631      so we should issue a warning.  */
3632   else if (warn_unused_value)
3633     warn_if_unused_value (TREE_VALUE (list));
3634
3635   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3636 }
3637
3638 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3639
3640 tree
3641 build_c_cast (type, expr)
3642      register tree type;
3643      tree expr;
3644 {
3645   register tree value = expr;
3646
3647   if (type == error_mark_node || expr == error_mark_node)
3648     return error_mark_node;
3649   type = TYPE_MAIN_VARIANT (type);
3650
3651 #if 0
3652   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3653   if (TREE_CODE (value) == NON_LVALUE_EXPR)
3654     value = TREE_OPERAND (value, 0);
3655 #endif
3656
3657   if (TREE_CODE (type) == ARRAY_TYPE)
3658     {
3659       error ("cast specifies array type");
3660       return error_mark_node;
3661     }
3662
3663   if (TREE_CODE (type) == FUNCTION_TYPE)
3664     {
3665       error ("cast specifies function type");
3666       return error_mark_node;
3667     }
3668
3669   if (type == TREE_TYPE (value))
3670     {
3671       if (pedantic)
3672         {
3673           if (TREE_CODE (type) == RECORD_TYPE
3674               || TREE_CODE (type) == UNION_TYPE)
3675             pedwarn ("ISO C forbids casting nonscalar to the same type");
3676         }
3677     }
3678   else if (TREE_CODE (type) == UNION_TYPE)
3679     {
3680       tree field;
3681       if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3682           || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3683         value = default_conversion (value);
3684
3685       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3686         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3687                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3688           break;
3689
3690       if (field)
3691         {
3692           const char *name;
3693           tree t;
3694
3695           if (pedantic)
3696             pedwarn ("ISO C forbids casts to union type");
3697           if (TYPE_NAME (type) != 0)
3698             {
3699               if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3700                 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3701               else
3702                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3703             }
3704           else
3705             name = "";
3706           t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3707                                         build_tree_list (field, value)),
3708                            0, 0);
3709           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3710           return t;
3711         }
3712       error ("cast to union type from type not present in union");
3713       return error_mark_node;
3714     }
3715   else
3716     {
3717       tree otype, ovalue;
3718
3719       /* If casting to void, avoid the error that would come
3720          from default_conversion in the case of a non-lvalue array.  */
3721       if (type == void_type_node)
3722         return build1 (CONVERT_EXPR, type, value);
3723
3724       /* Convert functions and arrays to pointers,
3725          but don't convert any other types.  */
3726       if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3727           || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3728         value = default_conversion (value);
3729       otype = TREE_TYPE (value);
3730
3731       /* Optionally warn about potentially worrisome casts.  */
3732
3733       if (warn_cast_qual
3734           && TREE_CODE (type) == POINTER_TYPE
3735           && TREE_CODE (otype) == POINTER_TYPE)
3736         {
3737           tree in_type = type;
3738           tree in_otype = otype;
3739           int warn = 0;
3740
3741           /* Check that the qualifiers on IN_TYPE are a superset of
3742              the qualifiers of IN_OTYPE.  The outermost level of
3743              POINTER_TYPE nodes is uninteresting and we stop as soon
3744              as we hit a non-POINTER_TYPE node on either type.  */
3745           do
3746             {
3747               in_otype = TREE_TYPE (in_otype);
3748               in_type = TREE_TYPE (in_type);
3749               warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3750             }
3751           while (TREE_CODE (in_type) == POINTER_TYPE
3752                  && TREE_CODE (in_otype) == POINTER_TYPE);
3753
3754           if (warn)
3755             /* There are qualifiers present in IN_OTYPE that are not
3756                present in IN_TYPE.  */
3757             warning ("cast discards qualifiers from pointer target type");
3758         }
3759
3760       /* Warn about possible alignment problems.  */
3761       if (STRICT_ALIGNMENT && warn_cast_align
3762           && TREE_CODE (type) == POINTER_TYPE
3763           && TREE_CODE (otype) == POINTER_TYPE
3764           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3765           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3766           /* Don't warn about opaque types, where the actual alignment
3767              restriction is unknown.  */
3768           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3769                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3770                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3771           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3772         warning ("cast increases required alignment of target type");
3773
3774       if (TREE_CODE (type) == INTEGER_TYPE
3775           && TREE_CODE (otype) == POINTER_TYPE
3776           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3777           && !TREE_CONSTANT (value))
3778         warning ("cast from pointer to integer of different size");
3779
3780       if (warn_bad_function_cast
3781           && TREE_CODE (value) == CALL_EXPR
3782           && TREE_CODE (type) != TREE_CODE (otype))
3783         warning ("cast does not match function type");
3784
3785       if (TREE_CODE (type) == POINTER_TYPE
3786           && TREE_CODE (otype) == INTEGER_TYPE
3787           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3788           /* Don't warn about converting any constant.  */
3789           && !TREE_CONSTANT (value))
3790         warning ("cast to pointer from integer of different size");
3791
3792       ovalue = value;
3793       value = convert (type, value);
3794
3795       /* Ignore any integer overflow caused by the cast.  */
3796       if (TREE_CODE (value) == INTEGER_CST)
3797         {
3798           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3799           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3800         }
3801     }
3802
3803   /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant.  */
3804   if (pedantic && TREE_CODE (value) == INTEGER_CST
3805       && TREE_CODE (expr) == INTEGER_CST
3806       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3807     value = non_lvalue (value);
3808
3809   /* If pedantic, don't let a cast be an lvalue.  */
3810   if (value == expr && pedantic)
3811     value = non_lvalue (value);
3812
3813   return value;
3814 }
3815 \f
3816 /* Build an assignment expression of lvalue LHS from value RHS.
3817    MODIFYCODE is the code for a binary operator that we use
3818    to combine the old value of LHS with RHS to get the new value.
3819    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3820
3821 tree
3822 build_modify_expr (lhs, modifycode, rhs)
3823      tree lhs, rhs;
3824      enum tree_code modifycode;
3825 {
3826   register tree result;
3827   tree newrhs;
3828   tree lhstype = TREE_TYPE (lhs);
3829   tree olhstype = lhstype;
3830
3831   /* Types that aren't fully specified cannot be used in assignments.  */
3832   lhs = require_complete_type (lhs);
3833
3834   /* Avoid duplicate error messages from operands that had errors.  */
3835   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3836     return error_mark_node;
3837
3838   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3839   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3840      whose value is 0 to count as a null pointer constant.  */
3841   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3842     rhs = TREE_OPERAND (rhs, 0);
3843
3844   newrhs = rhs;
3845
3846   /* Handle control structure constructs used as "lvalues".  */
3847
3848   switch (TREE_CODE (lhs))
3849     {
3850       /* Handle (a, b) used as an "lvalue".  */
3851     case COMPOUND_EXPR:
3852       pedantic_lvalue_warning (COMPOUND_EXPR);
3853       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3854       if (TREE_CODE (newrhs) == ERROR_MARK)
3855         return error_mark_node;
3856       return build (COMPOUND_EXPR, lhstype,
3857                     TREE_OPERAND (lhs, 0), newrhs);
3858
3859       /* Handle (a ? b : c) used as an "lvalue".  */
3860     case COND_EXPR:
3861       pedantic_lvalue_warning (COND_EXPR);
3862       rhs = save_expr (rhs);
3863       {
3864         /* Produce (a ? (b = rhs) : (c = rhs))
3865            except that the RHS goes through a save-expr
3866            so the code to compute it is only emitted once.  */
3867         tree cond
3868           = build_conditional_expr (TREE_OPERAND (lhs, 0),
3869                                     build_modify_expr (TREE_OPERAND (lhs, 1),
3870                                                        modifycode, rhs),
3871                                     build_modify_expr (TREE_OPERAND (lhs, 2),
3872                                                        modifycode, rhs));
3873         if (TREE_CODE (cond) == ERROR_MARK)
3874           return cond;
3875         /* Make sure the code to compute the rhs comes out
3876            before the split.  */
3877         return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3878                       /* But cast it to void to avoid an "unused" error.  */
3879                       convert (void_type_node, rhs), cond);
3880       }
3881     default:
3882       break;
3883     }
3884
3885   /* If a binary op has been requested, combine the old LHS value with the RHS
3886      producing the value we should actually store into the LHS.  */
3887
3888   if (modifycode != NOP_EXPR)
3889     {
3890       lhs = stabilize_reference (lhs);
3891       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3892     }
3893
3894   /* Handle a cast used as an "lvalue".
3895      We have already performed any binary operator using the value as cast.
3896      Now convert the result to the cast type of the lhs,
3897      and then true type of the lhs and store it there;
3898      then convert result back to the cast type to be the value
3899      of the assignment.  */
3900
3901   switch (TREE_CODE (lhs))
3902     {
3903     case NOP_EXPR:
3904     case CONVERT_EXPR:
3905     case FLOAT_EXPR:
3906     case FIX_TRUNC_EXPR:
3907     case FIX_FLOOR_EXPR:
3908     case FIX_ROUND_EXPR:
3909     case FIX_CEIL_EXPR:
3910       if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3911           || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3912         newrhs = default_conversion (newrhs);
3913       {
3914         tree inner_lhs = TREE_OPERAND (lhs, 0);
3915         tree result;
3916         result = build_modify_expr (inner_lhs, NOP_EXPR,
3917                                     convert (TREE_TYPE (inner_lhs),
3918                                              convert (lhstype, newrhs)));
3919         if (TREE_CODE (result) == ERROR_MARK)
3920           return result;
3921         pedantic_lvalue_warning (CONVERT_EXPR);
3922         return convert (TREE_TYPE (lhs), result);
3923       }
3924
3925     default:
3926       break;
3927     }
3928
3929   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3930      Reject anything strange now.  */
3931
3932   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3933     return error_mark_node;
3934
3935   /* Warn about storing in something that is `const'.  */
3936
3937   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3938       || ((TREE_CODE (lhstype) == RECORD_TYPE
3939            || TREE_CODE (lhstype) == UNION_TYPE)
3940           && C_TYPE_FIELDS_READONLY (lhstype)))
3941     readonly_warning (lhs, "assignment");
3942
3943   /* If storing into a structure or union member,
3944      it has probably been given type `int'.
3945      Compute the type that would go with
3946      the actual amount of storage the member occupies.  */
3947
3948   if (TREE_CODE (lhs) == COMPONENT_REF
3949       && (TREE_CODE (lhstype) == INTEGER_TYPE
3950           || TREE_CODE (lhstype) == REAL_TYPE
3951           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3952     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3953
3954   /* If storing in a field that is in actuality a short or narrower than one,
3955      we must store in the field in its actual type.  */
3956
3957   if (lhstype != TREE_TYPE (lhs))
3958     {
3959       lhs = copy_node (lhs);
3960       TREE_TYPE (lhs) = lhstype;
3961     }
3962
3963   /* Convert new value to destination type.  */
3964
3965   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3966                                    NULL_TREE, NULL_TREE, 0);
3967   if (TREE_CODE (newrhs) == ERROR_MARK)
3968     return error_mark_node;
3969
3970   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3971   TREE_SIDE_EFFECTS (result) = 1;
3972
3973   /* If we got the LHS in a different type for storing in,
3974      convert the result back to the nominal type of LHS
3975      so that the value we return always has the same type
3976      as the LHS argument.  */
3977
3978   if (olhstype == TREE_TYPE (result))
3979     return result;
3980   return convert_for_assignment (olhstype, result, _("assignment"),
3981                                  NULL_TREE, NULL_TREE, 0);
3982 }
3983 \f
3984 /* Convert value RHS to type TYPE as preparation for an assignment
3985    to an lvalue of type TYPE.
3986    The real work of conversion is done by `convert'.
3987    The purpose of this function is to generate error messages
3988    for assignments that are not allowed in C.
3989    ERRTYPE is a string to use in error messages:
3990    "assignment", "return", etc.  If it is null, this is parameter passing
3991    for a function call (and different error messages are output).
3992
3993    FUNNAME is the name of the function being called,
3994    as an IDENTIFIER_NODE, or null.
3995    PARMNUM is the number of the argument, for printing in error messages.  */
3996
3997 static tree
3998 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
3999      tree type, rhs;
4000      const char *errtype;
4001      tree fundecl, funname;
4002      int parmnum;
4003 {
4004   register enum tree_code codel = TREE_CODE (type);
4005   register tree rhstype;
4006   register enum tree_code coder;
4007
4008   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4009   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4010      whose value is 0 to count as a null pointer constant.  */
4011   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4012     rhs = TREE_OPERAND (rhs, 0);
4013
4014   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4015       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4016     rhs = default_conversion (rhs);
4017   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4018     rhs = decl_constant_value (rhs);
4019
4020   rhstype = TREE_TYPE (rhs);
4021   coder = TREE_CODE (rhstype);
4022
4023   if (coder == ERROR_MARK)
4024     return error_mark_node;
4025
4026   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4027     {
4028       overflow_warning (rhs);
4029       /* Check for Objective-C protocols.  This will issue a warning if
4030          there are protocol violations.  No need to use the return value.  */
4031       maybe_objc_comptypes (type, rhstype, 0);
4032       return rhs;
4033     }
4034
4035   if (coder == VOID_TYPE)
4036     {
4037       error ("void value not ignored as it ought to be");
4038       return error_mark_node;
4039     }
4040   /* A type converts to a reference to it.
4041      This code doesn't fully support references, it's just for the
4042      special case of va_start and va_copy.  */
4043   if (codel == REFERENCE_TYPE
4044       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4045     {
4046       if (mark_addressable (rhs) == 0)
4047         return error_mark_node;
4048       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4049
4050       /* We already know that these two types are compatible, but they
4051          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
4052          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4053          likely to be va_list, a typedef to __builtin_va_list, which
4054          is different enough that it will cause problems later.  */
4055       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4056         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4057
4058       rhs = build1 (NOP_EXPR, type, rhs);
4059       return rhs;
4060     }
4061   /* Arithmetic types all interconvert, and enum is treated like int.  */
4062   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4063             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE)
4064            && (coder == INTEGER_TYPE || coder == REAL_TYPE
4065                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE))
4066     return convert_and_check (type, rhs);
4067
4068   /* Conversion to a transparent union from its member types.
4069      This applies only to function arguments.  */
4070   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4071     {
4072       tree memb_types;
4073       tree marginal_memb_type = 0;
4074
4075       for (memb_types = TYPE_FIELDS (type); memb_types;
4076            memb_types = TREE_CHAIN (memb_types))
4077         {
4078           tree memb_type = TREE_TYPE (memb_types);
4079
4080           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4081                          TYPE_MAIN_VARIANT (rhstype)))
4082             break;
4083
4084           if (TREE_CODE (memb_type) != POINTER_TYPE)
4085             continue;
4086
4087           if (coder == POINTER_TYPE)
4088             {
4089               register tree ttl = TREE_TYPE (memb_type);
4090               register tree ttr = TREE_TYPE (rhstype);
4091
4092               /* Any non-function converts to a [const][volatile] void *
4093                  and vice versa; otherwise, targets must be the same.
4094                  Meanwhile, the lhs target must have all the qualifiers of
4095                  the rhs.  */
4096               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4097                   || comp_target_types (memb_type, rhstype))
4098                 {
4099                   /* If this type won't generate any warnings, use it.  */
4100                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4101                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
4102                            && TREE_CODE (ttl) == FUNCTION_TYPE)
4103                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4104                              == TYPE_QUALS (ttr))
4105                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4106                              == TYPE_QUALS (ttl))))
4107                     break;
4108
4109                   /* Keep looking for a better type, but remember this one.  */
4110                   if (! marginal_memb_type)
4111                     marginal_memb_type = memb_type;
4112                 }
4113             }
4114
4115           /* Can convert integer zero to any pointer type.  */
4116           if (integer_zerop (rhs)
4117               || (TREE_CODE (rhs) == NOP_EXPR
4118                   && integer_zerop (TREE_OPERAND (rhs, 0))))
4119             {
4120               rhs = null_pointer_node;
4121               break;
4122             }
4123         }
4124
4125       if (memb_types || marginal_memb_type)
4126         {
4127           if (! memb_types)
4128             {
4129               /* We have only a marginally acceptable member type;
4130                  it needs a warning.  */
4131               register tree ttl = TREE_TYPE (marginal_memb_type);
4132               register tree ttr = TREE_TYPE (rhstype);
4133
4134               /* Const and volatile mean something different for function
4135                  types, so the usual warnings are not appropriate.  */
4136               if (TREE_CODE (ttr) == FUNCTION_TYPE
4137                   && TREE_CODE (ttl) == FUNCTION_TYPE)
4138                 {
4139                   /* Because const and volatile on functions are
4140                      restrictions that say the function will not do
4141                      certain things, it is okay to use a const or volatile
4142                      function where an ordinary one is wanted, but not
4143                      vice-versa.  */
4144                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4145                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
4146                                          errtype, funname, parmnum);
4147                 }
4148               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4149                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4150                                      errtype, funname,
4151                                      parmnum);
4152             }
4153
4154           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4155             pedwarn ("ISO C prohibits argument conversion to union type");
4156
4157           return build1 (NOP_EXPR, type, rhs);
4158         }
4159     }
4160
4161   /* Conversions among pointers */
4162   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4163            && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4164     {
4165       register tree ttl = TREE_TYPE (type);
4166       register tree ttr = TREE_TYPE (rhstype);
4167
4168       /* Any non-function converts to a [const][volatile] void *
4169          and vice versa; otherwise, targets must be the same.
4170          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4171       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4172           || comp_target_types (type, rhstype)
4173           || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4174               == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4175         {
4176           if (pedantic
4177               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4178                   ||
4179                   (VOID_TYPE_P (ttr)
4180                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
4181                       which are not ANSI null ptr constants.  */
4182                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4183                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4184             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4185                                  errtype, funname, parmnum);
4186           /* Const and volatile mean something different for function types,
4187              so the usual warnings are not appropriate.  */
4188           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4189                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4190             {
4191               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4192                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4193                                      errtype, funname, parmnum);
4194               /* If this is not a case of ignoring a mismatch in signedness,
4195                  no warning.  */
4196               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4197                        || comp_target_types (type, rhstype))
4198                 ;
4199               /* If there is a mismatch, do warn.  */
4200               else if (pedantic)
4201                 warn_for_assignment ("pointer targets in %s differ in signedness",
4202                                      errtype, funname, parmnum);
4203             }
4204           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4205                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4206             {
4207               /* Because const and volatile on functions are restrictions
4208                  that say the function will not do certain things,
4209                  it is okay to use a const or volatile function
4210                  where an ordinary one is wanted, but not vice-versa.  */
4211               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4212                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4213                                      errtype, funname, parmnum);
4214             }
4215         }
4216       else
4217         warn_for_assignment ("%s from incompatible pointer type",
4218                              errtype, funname, parmnum);
4219       return convert (type, rhs);
4220     }
4221   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4222     {
4223       /* An explicit constant 0 can convert to a pointer,
4224          or one that results from arithmetic, even including
4225          a cast to integer type.  */
4226       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4227           &&
4228           ! (TREE_CODE (rhs) == NOP_EXPR
4229              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4230              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4231              && integer_zerop (TREE_OPERAND (rhs, 0))))
4232         {
4233           warn_for_assignment ("%s makes pointer from integer without a cast",
4234                                errtype, funname, parmnum);
4235           return convert (type, rhs);
4236         }
4237       return null_pointer_node;
4238     }
4239   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4240     {
4241       warn_for_assignment ("%s makes integer from pointer without a cast",
4242                            errtype, funname, parmnum);
4243       return convert (type, rhs);
4244     }
4245
4246   if (!errtype)
4247     {
4248       if (funname)
4249         {
4250           tree selector = maybe_building_objc_message_expr ();
4251
4252           if (selector && parmnum > 2)
4253             error ("incompatible type for argument %d of `%s'",
4254                    parmnum - 2, IDENTIFIER_POINTER (selector));
4255           else
4256             error ("incompatible type for argument %d of `%s'",
4257                    parmnum, IDENTIFIER_POINTER (funname));
4258         }
4259       else
4260         error ("incompatible type for argument %d of indirect function call",
4261                parmnum);
4262     }
4263   else
4264     error ("incompatible types in %s", errtype);
4265
4266   return error_mark_node;
4267 }
4268
4269 /* Print a warning using MSGID.
4270    It gets OPNAME as its one parameter.
4271    If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4272    FUNCTION and ARGNUM are handled specially if we are building an
4273    Objective-C selector.  */
4274
4275 static void
4276 warn_for_assignment (msgid, opname, function, argnum)
4277      const char *msgid;
4278      const char *opname;
4279      tree function;
4280      int argnum;
4281 {
4282   if (opname == 0)
4283     {
4284       tree selector = maybe_building_objc_message_expr ();
4285       char * new_opname;
4286
4287       if (selector && argnum > 2)
4288         {
4289           function = selector;
4290           argnum -= 2;
4291         }
4292       if (function)
4293         {
4294           /* Function name is known; supply it.  */
4295           const char *argstring = _("passing arg %d of `%s'");
4296           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4297                                         + strlen (argstring) + 1 + 25
4298                                         /*%d*/ + 1);
4299           sprintf (new_opname, argstring, argnum,
4300                    IDENTIFIER_POINTER (function));
4301         }
4302       else
4303         {
4304           /* Function name unknown (call through ptr); just give arg number.*/
4305           const char *argnofun = _("passing arg %d of pointer to function");
4306           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4307           sprintf (new_opname, argnofun, argnum);
4308         }
4309       opname = new_opname;
4310     }
4311   pedwarn (msgid, opname);
4312 }
4313 \f
4314 /* If VALUE is a compound expr all of whose expressions are constant, then
4315    return its value.  Otherwise, return error_mark_node.
4316
4317    This is for handling COMPOUND_EXPRs as initializer elements
4318    which is allowed with a warning when -pedantic is specified.  */
4319
4320 static tree
4321 valid_compound_expr_initializer (value, endtype)
4322      tree value;
4323      tree endtype;
4324 {
4325   if (TREE_CODE (value) == COMPOUND_EXPR)
4326     {
4327       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4328           == error_mark_node)
4329         return error_mark_node;
4330       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4331                                               endtype);
4332     }
4333   else if (! TREE_CONSTANT (value)
4334            && ! initializer_constant_valid_p (value, endtype))
4335     return error_mark_node;
4336   else
4337     return value;
4338 }
4339 \f
4340 /* Perform appropriate conversions on the initial value of a variable,
4341    store it in the declaration DECL,
4342    and print any error messages that are appropriate.
4343    If the init is invalid, store an ERROR_MARK.  */
4344
4345 void
4346 store_init_value (decl, init)
4347      tree decl, init;
4348 {
4349   register tree value, type;
4350
4351   /* If variable's type was invalidly declared, just ignore it.  */
4352
4353   type = TREE_TYPE (decl);
4354   if (TREE_CODE (type) == ERROR_MARK)
4355     return;
4356
4357   /* Digest the specified initializer into an expression.  */
4358
4359   value = digest_init (type, init, TREE_STATIC (decl),
4360                        TREE_STATIC (decl) || pedantic);
4361
4362   /* Store the expression if valid; else report error.  */
4363
4364 #if 0
4365   /* Note that this is the only place we can detect the error
4366      in a case such as   struct foo bar = (struct foo) { x, y };
4367      where there is one initial value which is a constructor expression.  */
4368   if (value == error_mark_node)
4369     ;
4370   else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4371     {
4372       error ("initializer for static variable is not constant");
4373       value = error_mark_node;
4374     }
4375   else if (TREE_STATIC (decl)
4376            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4377     {
4378       error ("initializer for static variable uses complicated arithmetic");
4379       value = error_mark_node;
4380     }
4381   else
4382     {
4383       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4384         {
4385           if (! TREE_CONSTANT (value))
4386             pedwarn ("aggregate initializer is not constant");
4387           else if (! TREE_STATIC (value))
4388             pedwarn ("aggregate initializer uses complicated arithmetic");
4389         }
4390     }
4391 #endif
4392
4393   if (warn_traditional && !in_system_header
4394       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4395     warning ("traditional C rejects automatic aggregate initialization");
4396
4397   DECL_INITIAL (decl) = value;
4398
4399   /* ANSI wants warnings about out-of-range constant initializers.  */
4400   STRIP_TYPE_NOPS (value);
4401   constant_expression_warning (value);
4402 }
4403 \f
4404 /* Methods for storing and printing names for error messages.  */
4405
4406 /* Implement a spelling stack that allows components of a name to be pushed
4407    and popped.  Each element on the stack is this structure.  */
4408
4409 struct spelling
4410 {
4411   int kind;
4412   union
4413     {
4414       int i;
4415       const char *s;
4416     } u;
4417 };
4418
4419 #define SPELLING_STRING 1
4420 #define SPELLING_MEMBER 2
4421 #define SPELLING_BOUNDS 3
4422
4423 static struct spelling *spelling;       /* Next stack element (unused).  */
4424 static struct spelling *spelling_base;  /* Spelling stack base.  */
4425 static int spelling_size;               /* Size of the spelling stack.  */
4426
4427 /* Macros to save and restore the spelling stack around push_... functions.
4428    Alternative to SAVE_SPELLING_STACK.  */
4429
4430 #define SPELLING_DEPTH() (spelling - spelling_base)
4431 #define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
4432
4433 /* Save and restore the spelling stack around arbitrary C code.  */
4434
4435 #define SAVE_SPELLING_DEPTH(code)               \
4436 {                                               \
4437   int __depth = SPELLING_DEPTH ();              \
4438   code;                                         \
4439   RESTORE_SPELLING_DEPTH (__depth);             \
4440 }
4441
4442 /* Push an element on the spelling stack with type KIND and assign VALUE
4443    to MEMBER.  */
4444
4445 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4446 {                                                                       \
4447   int depth = SPELLING_DEPTH ();                                        \
4448                                                                         \
4449   if (depth >= spelling_size)                                           \
4450     {                                                                   \
4451       spelling_size += 10;                                              \
4452       if (spelling_base == 0)                                           \
4453         spelling_base                                                   \
4454           = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));     \
4455       else                                                              \
4456         spelling_base                                                   \
4457           = (struct spelling *) xrealloc (spelling_base,                \
4458                                           spelling_size * sizeof (struct spelling));    \
4459       RESTORE_SPELLING_DEPTH (depth);                                   \
4460     }                                                                   \
4461                                                                         \
4462   spelling->kind = (KIND);                                              \
4463   spelling->MEMBER = (VALUE);                                           \
4464   spelling++;                                                           \
4465 }
4466
4467 /* Push STRING on the stack.  Printed literally.  */
4468
4469 static void
4470 push_string (string)
4471      const char *string;
4472 {
4473   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4474 }
4475
4476 /* Push a member name on the stack.  Printed as '.' STRING.  */
4477
4478 static void
4479 push_member_name (decl)
4480      tree decl;
4481
4482 {
4483   const char *string
4484     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4485   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4486 }
4487
4488 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4489
4490 static void
4491 push_array_bounds (bounds)
4492      int bounds;
4493 {
4494   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4495 }
4496
4497 /* Compute the maximum size in bytes of the printed spelling.  */
4498
4499 static int
4500 spelling_length ()
4501 {
4502   register int size = 0;
4503   register struct spelling *p;
4504
4505   for (p = spelling_base; p < spelling; p++)
4506     {
4507       if (p->kind == SPELLING_BOUNDS)
4508         size += 25;
4509       else
4510         size += strlen (p->u.s) + 1;
4511     }
4512
4513   return size;
4514 }
4515
4516 /* Print the spelling to BUFFER and return it.  */
4517
4518 static char *
4519 print_spelling (buffer)
4520      register char *buffer;
4521 {
4522   register char *d = buffer;
4523   register struct spelling *p;
4524
4525   for (p = spelling_base; p < spelling; p++)
4526     if (p->kind == SPELLING_BOUNDS)
4527       {
4528         sprintf (d, "[%d]", p->u.i);
4529         d += strlen (d);
4530       }
4531     else
4532       {
4533         register const char *s;
4534         if (p->kind == SPELLING_MEMBER)
4535           *d++ = '.';
4536         for (s = p->u.s; (*d = *s++); d++)
4537           ;
4538       }
4539   *d++ = '\0';
4540   return buffer;
4541 }
4542
4543 /* Issue an error message for a bad initializer component.
4544    MSGID identifies the message.
4545    The component name is taken from the spelling stack.  */
4546
4547 void
4548 error_init (msgid)
4549      const char *msgid;
4550 {
4551   char *ofwhat;
4552
4553   error ("%s", msgid);
4554   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4555   if (*ofwhat)
4556     error ("(near initialization for `%s')", ofwhat);
4557 }
4558
4559 /* Issue a pedantic warning for a bad initializer component.
4560    MSGID identifies the message.
4561    The component name is taken from the spelling stack.  */
4562
4563 void
4564 pedwarn_init (msgid)
4565      const char *msgid;
4566 {
4567   char *ofwhat;
4568
4569   pedwarn ("%s", msgid);
4570   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4571   if (*ofwhat)
4572     pedwarn ("(near initialization for `%s')", ofwhat);
4573 }
4574
4575 /* Issue a warning for a bad initializer component.
4576    MSGID identifies the message.
4577    The component name is taken from the spelling stack.  */
4578
4579 static void
4580 warning_init (msgid)
4581      const char *msgid;
4582 {
4583   char *ofwhat;
4584
4585   warning ("%s", msgid);
4586   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4587   if (*ofwhat)
4588     warning ("(near initialization for `%s')", ofwhat);
4589 }
4590 \f
4591 /* Digest the parser output INIT as an initializer for type TYPE.
4592    Return a C expression of type TYPE to represent the initial value.
4593
4594    The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4595    if non-constant initializers or elements are seen.  CONSTRUCTOR_CONSTANT
4596    applies only to elements of constructors.  */
4597
4598 static tree
4599 digest_init (type, init, require_constant, constructor_constant)
4600      tree type, init;
4601      int require_constant, constructor_constant;
4602 {
4603   enum tree_code code = TREE_CODE (type);
4604   tree inside_init = init;
4605
4606   if (type == error_mark_node
4607       || init == error_mark_node
4608       || TREE_TYPE (init)  == error_mark_node)
4609     return error_mark_node;
4610
4611   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4612   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4613      whose value is 0 to count as a null pointer constant.  */
4614   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4615     inside_init = TREE_OPERAND (init, 0);
4616
4617   /* Initialization of an array of chars from a string constant
4618      optionally enclosed in braces.  */
4619
4620   if (code == ARRAY_TYPE)
4621     {
4622       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4623       if ((typ1 == char_type_node
4624            || typ1 == signed_char_type_node
4625            || typ1 == unsigned_char_type_node
4626            || typ1 == unsigned_wchar_type_node
4627            || typ1 == signed_wchar_type_node)
4628           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4629         {
4630           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4631                          TYPE_MAIN_VARIANT (type)))
4632             return inside_init;
4633
4634           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4635                != char_type_node)
4636               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4637             {
4638               error_init ("char-array initialized from wide string");
4639               return error_mark_node;
4640             }
4641           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4642                == char_type_node)
4643               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4644             {
4645               error_init ("int-array initialized from non-wide string");
4646               return error_mark_node;
4647             }
4648
4649           TREE_TYPE (inside_init) = type;
4650           if (TYPE_DOMAIN (type) != 0
4651               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4652               /* Subtract 1 (or sizeof (wchar_t))
4653                  because it's ok to ignore the terminating null char
4654                  that is counted in the length of the constant.  */
4655               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4656                                        TREE_STRING_LENGTH (inside_init)
4657                                        - ((TYPE_PRECISION (typ1)
4658                                            != TYPE_PRECISION (char_type_node))
4659                                           ? (TYPE_PRECISION (wchar_type_node)
4660                                              / BITS_PER_UNIT)
4661                                           : 1)))
4662             pedwarn_init ("initializer-string for array of chars is too long");
4663
4664           return inside_init;
4665         }
4666     }
4667
4668   /* Any type can be initialized
4669      from an expression of the same type, optionally with braces.  */
4670
4671   if (inside_init && TREE_TYPE (inside_init) != 0
4672       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4673                      TYPE_MAIN_VARIANT (type))
4674           || (code == ARRAY_TYPE
4675               && comptypes (TREE_TYPE (inside_init), type))
4676           || (code == POINTER_TYPE
4677               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4678                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4679               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4680                             TREE_TYPE (type)))))
4681     {
4682       if (code == POINTER_TYPE
4683           && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4684               || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4685         inside_init = default_conversion (inside_init);
4686       else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4687                && TREE_CODE (inside_init) != CONSTRUCTOR)
4688         {
4689           error_init ("array initialized from non-constant array expression");
4690           return error_mark_node;
4691         }
4692
4693       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4694         inside_init = decl_constant_value (inside_init);
4695
4696       /* Compound expressions can only occur here if -pedantic or
4697          -pedantic-errors is specified.  In the later case, we always want
4698          an error.  In the former case, we simply want a warning.  */
4699       if (require_constant && pedantic
4700           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4701         {
4702           inside_init
4703             = valid_compound_expr_initializer (inside_init,
4704                                                TREE_TYPE (inside_init));
4705           if (inside_init == error_mark_node)
4706             error_init ("initializer element is not constant");
4707           else
4708             pedwarn_init ("initializer element is not constant");
4709           if (flag_pedantic_errors)
4710             inside_init = error_mark_node;
4711         }
4712       else if (require_constant && ! TREE_CONSTANT (inside_init))
4713         {
4714           error_init ("initializer element is not constant");
4715           inside_init = error_mark_node;
4716         }
4717       else if (require_constant
4718                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4719         {
4720           error_init ("initializer element is not computable at load time");
4721           inside_init = error_mark_node;
4722         }
4723
4724       return inside_init;
4725     }
4726
4727   /* Handle scalar types, including conversions.  */
4728
4729   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4730       || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
4731     {
4732       /* Note that convert_for_assignment calls default_conversion
4733          for arrays and functions.  We must not call it in the
4734          case where inside_init is a null pointer constant.  */
4735       inside_init
4736         = convert_for_assignment (type, init, _("initialization"),
4737                                   NULL_TREE, NULL_TREE, 0);
4738
4739       if (require_constant && ! TREE_CONSTANT (inside_init))
4740         {
4741           error_init ("initializer element is not constant");
4742           inside_init = error_mark_node;
4743         }
4744       else if (require_constant
4745                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4746         {
4747           error_init ("initializer element is not computable at load time");
4748           inside_init = error_mark_node;
4749         }
4750
4751       return inside_init;
4752     }
4753
4754   /* Come here only for records and arrays.  */
4755
4756   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4757     {
4758       error_init ("variable-sized object may not be initialized");
4759       return error_mark_node;
4760     }
4761
4762   /* Traditionally, you can write  struct foo x = 0;
4763      and it initializes the first element of x to 0.  */
4764   if (flag_traditional)
4765     {
4766       tree top = 0, prev = 0, otype = type;
4767       while (TREE_CODE (type) == RECORD_TYPE
4768              || TREE_CODE (type) == ARRAY_TYPE
4769              || TREE_CODE (type) == QUAL_UNION_TYPE
4770              || TREE_CODE (type) == UNION_TYPE)
4771         {
4772           tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4773           if (prev == 0)
4774             top = temp;
4775           else
4776             TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4777           prev = temp;
4778           if (TREE_CODE (type) == ARRAY_TYPE)
4779             type = TREE_TYPE (type);
4780           else if (TYPE_FIELDS (type))
4781             type = TREE_TYPE (TYPE_FIELDS (type));
4782           else
4783             {
4784               error_init ("invalid initializer");
4785               return error_mark_node;
4786             }
4787         }
4788
4789       if (otype != type)
4790         {
4791           TREE_OPERAND (prev, 1)
4792             = build_tree_list (NULL_TREE,
4793                                digest_init (type, init, require_constant,
4794                                             constructor_constant));
4795           return top;
4796         }
4797       else
4798         return error_mark_node;
4799     }
4800   error_init ("invalid initializer");
4801   return error_mark_node;
4802 }
4803 \f
4804 /* Handle initializers that use braces.  */
4805
4806 /* Type of object we are accumulating a constructor for.
4807    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4808 static tree constructor_type;
4809
4810 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4811    left to fill.  */
4812 static tree constructor_fields;
4813
4814 /* For an ARRAY_TYPE, this is the specified index
4815    at which to store the next element we get.  */
4816 static tree constructor_index;
4817
4818 /* For an ARRAY_TYPE, this is the end index of the range
4819    to initialize with the next element, or NULL in the ordinary case
4820    where the element is used just once.  */
4821 static tree constructor_range_end;
4822
4823 /* For an ARRAY_TYPE, this is the maximum index.  */
4824 static tree constructor_max_index;
4825
4826 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4827 static tree constructor_unfilled_fields;
4828
4829 /* For an ARRAY_TYPE, this is the index of the first element
4830    not yet written out.  */
4831 static tree constructor_unfilled_index;
4832
4833 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4834    This is so we can generate gaps between fields, when appropriate.  */
4835 static tree constructor_bit_index;
4836
4837 /* If we are saving up the elements rather than allocating them,
4838    this is the list of elements so far (in reverse order,
4839    most recent first).  */
4840 static tree constructor_elements;
4841
4842 /* 1 if so far this constructor's elements are all compile-time constants.  */
4843 static int constructor_constant;
4844
4845 /* 1 if so far this constructor's elements are all valid address constants.  */
4846 static int constructor_simple;
4847
4848 /* 1 if this constructor is erroneous so far.  */
4849 static int constructor_erroneous;
4850
4851 /* 1 if have called defer_addressed_constants.  */
4852 static int constructor_subconstants_deferred;
4853
4854 /* Structure for managing pending initializer elements, organized as an
4855    AVL tree.  */
4856
4857 struct init_node
4858 {
4859   struct init_node *left, *right;
4860   struct init_node *parent;
4861   int balance;
4862   tree purpose;
4863   tree value;
4864 };
4865
4866 /* Tree of pending elements at this constructor level.
4867    These are elements encountered out of order
4868    which belong at places we haven't reached yet in actually
4869    writing the output.
4870    Will never hold tree nodes across GC runs.  */
4871 static struct init_node *constructor_pending_elts;
4872
4873 /* The SPELLING_DEPTH of this constructor.  */
4874 static int constructor_depth;
4875
4876 /* 0 if implicitly pushing constructor levels is allowed.  */
4877 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4878
4879 static int require_constant_value;
4880 static int require_constant_elements;
4881
4882 /* 1 if it is ok to output this constructor as we read it.
4883    0 means must accumulate a CONSTRUCTOR expression.  */
4884 static int constructor_incremental;
4885
4886 /* DECL node for which an initializer is being read.
4887    0 means we are reading a constructor expression
4888    such as (struct foo) {...}.  */
4889 static tree constructor_decl;
4890
4891 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4892 static char *constructor_asmspec;
4893
4894 /* Nonzero if this is an initializer for a top-level decl.  */
4895 static int constructor_top_level;
4896
4897 \f
4898 /* This stack has a level for each implicit or explicit level of
4899    structuring in the initializer, including the outermost one.  It
4900    saves the values of most of the variables above.  */
4901
4902 struct constructor_stack
4903 {
4904   struct constructor_stack *next;
4905   tree type;
4906   tree fields;
4907   tree index;
4908   tree range_end;
4909   tree max_index;
4910   tree unfilled_index;
4911   tree unfilled_fields;
4912   tree bit_index;
4913   tree elements;
4914   int offset;
4915   struct init_node *pending_elts;
4916   int depth;
4917   /* If nonzero, this value should replace the entire
4918      constructor at this level.  */
4919   tree replacement_value;
4920   char constant;
4921   char simple;
4922   char implicit;
4923   char incremental;
4924   char erroneous;
4925   char outer;
4926 };
4927
4928 struct constructor_stack *constructor_stack;
4929
4930 /* This stack records separate initializers that are nested.
4931    Nested initializers can't happen in ANSI C, but GNU C allows them
4932    in cases like { ... (struct foo) { ... } ... }.  */
4933
4934 struct initializer_stack
4935 {
4936   struct initializer_stack *next;
4937   tree decl;
4938   char *asmspec;
4939   struct constructor_stack *constructor_stack;
4940   tree elements;
4941   struct spelling *spelling;
4942   struct spelling *spelling_base;
4943   int spelling_size;
4944   char top_level;
4945   char incremental;
4946   char require_constant_value;
4947   char require_constant_elements;
4948   char deferred;
4949 };
4950
4951 struct initializer_stack *initializer_stack;
4952 \f
4953 /* Prepare to parse and output the initializer for variable DECL.  */
4954
4955 void
4956 start_init (decl, asmspec_tree, top_level)
4957      tree decl;
4958      tree asmspec_tree;
4959      int top_level;
4960 {
4961   const char *locus;
4962   struct initializer_stack *p
4963     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
4964   char *asmspec = 0;
4965
4966   if (asmspec_tree)
4967     asmspec = TREE_STRING_POINTER (asmspec_tree);
4968
4969   p->decl = constructor_decl;
4970   p->asmspec = constructor_asmspec;
4971   p->incremental = constructor_incremental;
4972   p->require_constant_value = require_constant_value;
4973   p->require_constant_elements = require_constant_elements;
4974   p->constructor_stack = constructor_stack;
4975   p->elements = constructor_elements;
4976   p->spelling = spelling;
4977   p->spelling_base = spelling_base;
4978   p->spelling_size = spelling_size;
4979   p->deferred = constructor_subconstants_deferred;
4980   p->top_level = constructor_top_level;
4981   p->next = initializer_stack;
4982   initializer_stack = p;
4983
4984   constructor_decl = decl;
4985   constructor_incremental = top_level;
4986   constructor_asmspec = asmspec;
4987   constructor_subconstants_deferred = 0;
4988   constructor_top_level = top_level;
4989
4990   if (decl != 0)
4991     {
4992       require_constant_value = TREE_STATIC (decl);
4993       require_constant_elements
4994         = ((TREE_STATIC (decl) || pedantic)
4995            /* For a scalar, you can always use any value to initialize,
4996               even within braces.  */
4997            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4998                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4999                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5000                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5001       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5002       constructor_incremental |= TREE_STATIC (decl);
5003     }
5004   else
5005     {
5006       require_constant_value = 0;
5007       require_constant_elements = 0;
5008       locus = "(anonymous)";
5009     }
5010
5011   constructor_stack = 0;
5012
5013   missing_braces_mentioned = 0;
5014
5015   spelling_base = 0;
5016   spelling_size = 0;
5017   RESTORE_SPELLING_DEPTH (0);
5018
5019   if (locus)
5020     push_string (locus);
5021 }
5022
5023 void
5024 finish_init ()
5025 {
5026   struct initializer_stack *p = initializer_stack;
5027
5028   /* Output subconstants (string constants, usually)
5029      that were referenced within this initializer and saved up.
5030      Must do this if and only if we called defer_addressed_constants.  */
5031   if (constructor_subconstants_deferred)
5032     output_deferred_addressed_constants ();
5033
5034   /* Free the whole constructor stack of this initializer.  */
5035   while (constructor_stack)
5036     {
5037       struct constructor_stack *q = constructor_stack;
5038       constructor_stack = q->next;
5039       free (q);
5040     }
5041
5042   /* Pop back to the data of the outer initializer (if any).  */
5043   constructor_decl = p->decl;
5044   constructor_asmspec = p->asmspec;
5045   constructor_incremental = p->incremental;
5046   require_constant_value = p->require_constant_value;
5047   require_constant_elements = p->require_constant_elements;
5048   constructor_stack = p->constructor_stack;
5049   constructor_elements = p->elements;
5050   spelling = p->spelling;
5051   spelling_base = p->spelling_base;
5052   spelling_size = p->spelling_size;
5053   constructor_subconstants_deferred = p->deferred;
5054   constructor_top_level = p->top_level;
5055   initializer_stack = p->next;
5056   free (p);
5057 }
5058 \f
5059 /* Call here when we see the initializer is surrounded by braces.
5060    This is instead of a call to push_init_level;
5061    it is matched by a call to pop_init_level.
5062
5063    TYPE is the type to initialize, for a constructor expression.
5064    For an initializer for a decl, TYPE is zero.  */
5065
5066 void
5067 really_start_incremental_init (type)
5068      tree type;
5069 {
5070   struct constructor_stack *p
5071     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5072
5073   if (type == 0)
5074     type = TREE_TYPE (constructor_decl);
5075
5076   /* Turn off constructor_incremental if type is a struct with bitfields.
5077      Do this before the first push, so that the corrected value
5078      is available in finish_init.  */
5079   check_init_type_bitfields (type);
5080
5081   p->type = constructor_type;
5082   p->fields = constructor_fields;
5083   p->index = constructor_index;
5084   p->range_end = constructor_range_end;
5085   p->max_index = constructor_max_index;
5086   p->unfilled_index = constructor_unfilled_index;
5087   p->unfilled_fields = constructor_unfilled_fields;
5088   p->bit_index = constructor_bit_index;
5089   p->elements = constructor_elements;
5090   p->constant = constructor_constant;
5091   p->simple = constructor_simple;
5092   p->erroneous = constructor_erroneous;
5093   p->pending_elts = constructor_pending_elts;
5094   p->depth = constructor_depth;
5095   p->replacement_value = 0;
5096   p->implicit = 0;
5097   p->incremental = constructor_incremental;
5098   p->outer = 0;
5099   p->next = 0;
5100   constructor_stack = p;
5101
5102   constructor_constant = 1;
5103   constructor_simple = 1;
5104   constructor_depth = SPELLING_DEPTH ();
5105   constructor_elements = 0;
5106   constructor_pending_elts = 0;
5107   constructor_type = type;
5108
5109   if (TREE_CODE (constructor_type) == RECORD_TYPE
5110       || TREE_CODE (constructor_type) == UNION_TYPE)
5111     {
5112       constructor_fields = TYPE_FIELDS (constructor_type);
5113       /* Skip any nameless bit fields at the beginning.  */
5114       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5115              && DECL_NAME (constructor_fields) == 0)
5116         constructor_fields = TREE_CHAIN (constructor_fields);
5117
5118       constructor_unfilled_fields = constructor_fields;
5119       constructor_bit_index = bitsize_zero_node;
5120     }
5121   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5122     {
5123       constructor_range_end = 0;
5124       if (TYPE_DOMAIN (constructor_type))
5125         {
5126           constructor_max_index
5127             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5128           constructor_index
5129             = convert (bitsizetype,
5130                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5131         }
5132       else
5133         constructor_index = bitsize_zero_node;
5134
5135       constructor_unfilled_index = constructor_index;
5136     }
5137   else
5138     {
5139       /* Handle the case of int x = {5}; */
5140       constructor_fields = constructor_type;
5141       constructor_unfilled_fields = constructor_type;
5142     }
5143
5144   if (constructor_incremental)
5145     {
5146       make_decl_rtl (constructor_decl, constructor_asmspec,
5147                      constructor_top_level);
5148       assemble_variable (constructor_decl, constructor_top_level, 0, 1);
5149
5150       defer_addressed_constants ();
5151       constructor_subconstants_deferred = 1;
5152     }
5153 }
5154 \f
5155 /* Push down into a subobject, for initialization.
5156    If this is for an explicit set of braces, IMPLICIT is 0.
5157    If it is because the next element belongs at a lower level,
5158    IMPLICIT is 1.  */
5159
5160 void
5161 push_init_level (implicit)
5162      int implicit;
5163 {
5164   struct constructor_stack *p;
5165
5166   /* If we've exhausted any levels that didn't have braces,
5167      pop them now.  */
5168   while (constructor_stack->implicit)
5169     {
5170       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5171            || TREE_CODE (constructor_type) == UNION_TYPE)
5172           && constructor_fields == 0)
5173         process_init_element (pop_init_level (1));
5174       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5175                && tree_int_cst_lt (constructor_max_index, constructor_index))
5176         process_init_element (pop_init_level (1));
5177       else
5178         break;
5179     }
5180
5181   /* Structure elements may require alignment.  Do this now if necessary
5182      for the subaggregate, and if it comes next in sequence.  Don't do
5183      this for subaggregates that will go on the pending list.  */
5184   if (constructor_incremental && constructor_type != 0
5185       && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields
5186       && constructor_fields == constructor_unfilled_fields)
5187     {
5188       /* Advance to offset of this element.  */
5189       if (! tree_int_cst_equal (constructor_bit_index,
5190                                 bit_position (constructor_fields)))
5191         assemble_zeros
5192           (tree_low_cst
5193            (size_binop (TRUNC_DIV_EXPR,
5194                         size_binop (MINUS_EXPR,
5195                                     bit_position (constructor_fields),
5196                                     constructor_bit_index),
5197                         bitsize_unit_node),
5198             1));
5199
5200       /* Indicate that we have now filled the structure up to the current
5201          field.  */
5202       constructor_unfilled_fields = constructor_fields;
5203     }
5204
5205   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5206   p->type = constructor_type;
5207   p->fields = constructor_fields;
5208   p->index = constructor_index;
5209   p->range_end = constructor_range_end;
5210   p->max_index = constructor_max_index;
5211   p->unfilled_index = constructor_unfilled_index;
5212   p->unfilled_fields = constructor_unfilled_fields;
5213   p->bit_index = constructor_bit_index;
5214   p->elements = constructor_elements;
5215   p->constant = constructor_constant;
5216   p->simple = constructor_simple;
5217   p->erroneous = constructor_erroneous;
5218   p->pending_elts = constructor_pending_elts;
5219   p->depth = constructor_depth;
5220   p->replacement_value = 0;
5221   p->implicit = implicit;
5222   p->incremental = constructor_incremental;
5223   p->outer = 0;
5224   p->next = constructor_stack;
5225   constructor_stack = p;
5226
5227   constructor_constant = 1;
5228   constructor_simple = 1;
5229   constructor_depth = SPELLING_DEPTH ();
5230   constructor_elements = 0;
5231   constructor_pending_elts = 0;
5232
5233   /* Don't die if an entire brace-pair level is superfluous
5234      in the containing level.  */
5235   if (constructor_type == 0)
5236     ;
5237   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5238            || TREE_CODE (constructor_type) == UNION_TYPE)
5239     {
5240       /* Don't die if there are extra init elts at the end.  */
5241       if (constructor_fields == 0)
5242         constructor_type = 0;
5243       else
5244         {
5245           constructor_type = TREE_TYPE (constructor_fields);
5246           push_member_name (constructor_fields);
5247           constructor_depth++;
5248           if (constructor_fields != constructor_unfilled_fields)
5249             constructor_incremental = 0;
5250         }
5251     }
5252   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5253     {
5254       constructor_type = TREE_TYPE (constructor_type);
5255       push_array_bounds (tree_low_cst (constructor_index, 0));
5256       constructor_depth++;
5257       if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
5258           || constructor_range_end != 0)
5259         constructor_incremental = 0;
5260     }
5261
5262   if (constructor_type == 0)
5263     {
5264       error_init ("extra brace group at end of initializer");
5265       constructor_fields = 0;
5266       constructor_unfilled_fields = 0;
5267       return;
5268     }
5269
5270   /* Turn off constructor_incremental if type is a struct with bitfields.  */
5271   check_init_type_bitfields (constructor_type);
5272
5273   if (implicit && warn_missing_braces && !missing_braces_mentioned)
5274     {
5275       missing_braces_mentioned = 1;
5276       warning_init ("missing braces around initializer");
5277     }
5278
5279   if (TREE_CODE (constructor_type) == RECORD_TYPE
5280            || TREE_CODE (constructor_type) == UNION_TYPE)
5281     {
5282       constructor_fields = TYPE_FIELDS (constructor_type);
5283       /* Skip any nameless bit fields at the beginning.  */
5284       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5285              && DECL_NAME (constructor_fields) == 0)
5286         constructor_fields = TREE_CHAIN (constructor_fields);
5287
5288       constructor_unfilled_fields = constructor_fields;
5289       constructor_bit_index = bitsize_zero_node;
5290     }
5291   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5292     {
5293       constructor_range_end = 0;
5294       if (TYPE_DOMAIN (constructor_type))
5295         {
5296           constructor_max_index
5297             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5298           constructor_index
5299             = convert (bitsizetype,
5300                                   TYPE_MIN_VALUE
5301                                   (TYPE_DOMAIN (constructor_type)));
5302         }
5303       else
5304         constructor_index = bitsize_zero_node;
5305
5306       constructor_unfilled_index = constructor_index;
5307     }
5308   else
5309     {
5310       warning_init ("braces around scalar initializer");
5311       constructor_fields = constructor_type;
5312       constructor_unfilled_fields = constructor_type;
5313     }
5314 }
5315
5316 /* Don't read a struct incrementally if it has any bitfields,
5317    because the incremental reading code doesn't know how to
5318    handle bitfields yet.  */
5319
5320 static void
5321 check_init_type_bitfields (type)
5322      tree type;
5323 {
5324   if (TREE_CODE (type) == RECORD_TYPE)
5325     {
5326       tree tail;
5327       for (tail = TYPE_FIELDS (type); tail;
5328            tail = TREE_CHAIN (tail))
5329         {
5330           if (DECL_C_BIT_FIELD (tail))
5331             {
5332               constructor_incremental = 0;
5333               break;
5334             }
5335
5336           check_init_type_bitfields (TREE_TYPE (tail));
5337         }
5338     }
5339
5340   else if (TREE_CODE (type) == UNION_TYPE)
5341     {
5342       tree tail = TYPE_FIELDS (type);
5343       if (tail && DECL_C_BIT_FIELD (tail))
5344         /* We also use the nonincremental algorithm for initiliazation
5345            of unions whose first member is a bitfield, becuase the
5346            incremental algorithm has no code for dealing with
5347            bitfields. */
5348         constructor_incremental = 0;
5349     }
5350
5351   else if (TREE_CODE (type) == ARRAY_TYPE)
5352     check_init_type_bitfields (TREE_TYPE (type));
5353 }
5354
5355 /* At the end of an implicit or explicit brace level,
5356    finish up that level of constructor.
5357    If we were outputting the elements as they are read, return 0
5358    from inner levels (process_init_element ignores that),
5359    but return error_mark_node from the outermost level
5360    (that's what we want to put in DECL_INITIAL).
5361    Otherwise, return a CONSTRUCTOR expression.  */
5362
5363 tree
5364 pop_init_level (implicit)
5365      int implicit;
5366 {
5367   struct constructor_stack *p;
5368   HOST_WIDE_INT size = 0;
5369   tree constructor = 0;
5370
5371   if (implicit == 0)
5372     {
5373       /* When we come to an explicit close brace,
5374          pop any inner levels that didn't have explicit braces.  */
5375       while (constructor_stack->implicit)
5376         process_init_element (pop_init_level (1));
5377     }
5378
5379   p = constructor_stack;
5380
5381   if (constructor_type != 0)
5382     size = int_size_in_bytes (constructor_type);
5383
5384   /* Warn when some struct elements are implicitly initialized to zero.  */
5385   if (extra_warnings
5386       && constructor_type
5387       && TREE_CODE (constructor_type) == RECORD_TYPE
5388       && constructor_unfilled_fields)
5389     {
5390       push_member_name (constructor_unfilled_fields);
5391       warning_init ("missing initializer");
5392       RESTORE_SPELLING_DEPTH (constructor_depth);
5393     }
5394
5395   /* Now output all pending elements.  */
5396   output_pending_init_elements (1);
5397
5398 #if 0 /* c-parse.in warns about {}.  */
5399   /* In ANSI, each brace level must have at least one element.  */
5400   if (! implicit && pedantic
5401       && (TREE_CODE (constructor_type) == ARRAY_TYPE
5402           ? integer_zerop (constructor_unfilled_index)
5403           : constructor_unfilled_fields == TYPE_FIELDS (constructor_type)))
5404     pedwarn_init ("empty braces in initializer");
5405 #endif
5406
5407   /* Pad out the end of the structure.  */
5408
5409   if (p->replacement_value)
5410     {
5411       /* If this closes a superfluous brace pair,
5412          just pass out the element between them.  */
5413       constructor = p->replacement_value;
5414       /* If this is the top level thing within the initializer,
5415          and it's for a variable, then since we already called
5416          assemble_variable, we must output the value now.  */
5417       if (p->next == 0 && constructor_decl != 0
5418           && constructor_incremental)
5419         {
5420           constructor = digest_init (constructor_type, constructor,
5421                                      require_constant_value,
5422                                      require_constant_elements);
5423
5424           /* If initializing an array of unknown size,
5425              determine the size now.  */
5426           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5427               && TYPE_DOMAIN (constructor_type) == 0)
5428             {
5429               /* We shouldn't have an incomplete array type within
5430                  some other type.  */
5431               if (constructor_stack->next)
5432                 abort ();
5433
5434               if (complete_array_type (constructor_type, constructor, 0))
5435                 abort ();
5436
5437               size = int_size_in_bytes (constructor_type);
5438             }
5439
5440           output_constant (constructor, size);
5441         }
5442     }
5443   else if (constructor_type == 0)
5444     ;
5445   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5446            && TREE_CODE (constructor_type) != UNION_TYPE
5447            && TREE_CODE (constructor_type) != ARRAY_TYPE
5448            && ! constructor_incremental)
5449     {
5450       /* A nonincremental scalar initializer--just return
5451          the element, after verifying there is just one.  */
5452       if (constructor_elements == 0)
5453         {
5454           error_init ("empty scalar initializer");
5455           constructor = error_mark_node;
5456         }
5457       else if (TREE_CHAIN (constructor_elements) != 0)
5458         {
5459           error_init ("extra elements in scalar initializer");
5460           constructor = TREE_VALUE (constructor_elements);
5461         }
5462       else
5463         constructor = TREE_VALUE (constructor_elements);
5464     }
5465   else if (! constructor_incremental)
5466     {
5467       if (constructor_erroneous)
5468         constructor = error_mark_node;
5469       else
5470         {
5471           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5472                                nreverse (constructor_elements));
5473           if (constructor_constant)
5474             TREE_CONSTANT (constructor) = 1;
5475           if (constructor_constant && constructor_simple)
5476             TREE_STATIC (constructor) = 1;
5477         }
5478     }
5479   else
5480     {
5481       tree filled;
5482
5483       if (TREE_CODE (constructor_type) == RECORD_TYPE
5484           || TREE_CODE (constructor_type) == UNION_TYPE)
5485         /* Find the offset of the end of that field.  */
5486         filled = size_binop (CEIL_DIV_EXPR, constructor_bit_index,
5487                              bitsize_unit_node);
5488
5489       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5490         {
5491           /* If initializing an array of unknown size,
5492              determine the size now.  */
5493           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5494               && TYPE_DOMAIN (constructor_type) == 0)
5495             {
5496               tree maxindex
5497                 = copy_node (size_diffop (constructor_unfilled_index,
5498                                           bitsize_one_node));
5499
5500               TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
5501               TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
5502
5503               /* TYPE_MAX_VALUE is always one less than the number of elements
5504                  in the array, because we start counting at zero.  Therefore,
5505                  warn only if the value is less than zero.  */
5506               if (pedantic
5507                   && (tree_int_cst_sgn
5508                       (TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5509                       < 0))
5510                 error_with_decl (constructor_decl,
5511                                  "zero or negative array size `%s'");
5512
5513               layout_type (constructor_type);
5514               size = int_size_in_bytes (constructor_type);
5515             }
5516
5517           filled
5518             = size_binop (MULT_EXPR, constructor_unfilled_index,
5519                           convert (bitsizetype,
5520                                    TYPE_SIZE_UNIT
5521                                    (TREE_TYPE (constructor_type))));
5522         }
5523       else
5524         filled = 0;
5525
5526       if (filled != 0)
5527         assemble_zeros (size - tree_low_cst (filled, 1));
5528     }
5529
5530
5531   constructor_type = p->type;
5532   constructor_fields = p->fields;
5533   constructor_index = p->index;
5534   constructor_range_end = p->range_end;
5535   constructor_max_index = p->max_index;
5536   constructor_unfilled_index = p->unfilled_index;
5537   constructor_unfilled_fields = p->unfilled_fields;
5538   constructor_bit_index = p->bit_index;
5539   constructor_elements = p->elements;
5540   constructor_constant = p->constant;
5541   constructor_simple = p->simple;
5542   constructor_erroneous = p->erroneous;
5543   constructor_pending_elts = p->pending_elts;
5544   constructor_depth = p->depth;
5545   constructor_incremental = p->incremental;
5546   RESTORE_SPELLING_DEPTH (constructor_depth);
5547
5548   constructor_stack = p->next;
5549   free (p);
5550
5551   if (constructor == 0)
5552     {
5553       if (constructor_stack == 0)
5554         return error_mark_node;
5555       return NULL_TREE;
5556     }
5557   return constructor;
5558 }
5559
5560 /* Within an array initializer, specify the next index to be initialized.
5561    FIRST is that index.  If LAST is nonzero, then initialize a range
5562    of indices, running from FIRST through LAST.  */
5563
5564 void
5565 set_init_index (first, last)
5566      tree first, last;
5567 {
5568   while ((TREE_CODE (first) == NOP_EXPR
5569           || TREE_CODE (first) == CONVERT_EXPR
5570           || TREE_CODE (first) == NON_LVALUE_EXPR)
5571          && (TYPE_MODE (TREE_TYPE (first))
5572              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5573     first = TREE_OPERAND (first, 0);
5574
5575   if (last)
5576     while ((TREE_CODE (last) == NOP_EXPR
5577             || TREE_CODE (last) == CONVERT_EXPR
5578             || TREE_CODE (last) == NON_LVALUE_EXPR)
5579            && (TYPE_MODE (TREE_TYPE (last))
5580                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5581       last = TREE_OPERAND (last, 0);
5582
5583   if (TREE_CODE (first) != INTEGER_CST)
5584     error_init ("nonconstant array index in initializer");
5585   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5586     error_init ("nonconstant array index in initializer");
5587   else if (! constructor_unfilled_index)
5588     error_init ("array index in non-array initializer");
5589   else if (tree_int_cst_lt (first, constructor_unfilled_index))
5590     error_init ("duplicate array index in initializer");
5591   else
5592     {
5593       constructor_index = convert (bitsizetype, first);
5594
5595       if (last != 0 && tree_int_cst_lt (last, first))
5596         error_init ("empty index range in initializer");
5597       else
5598         {
5599           if (pedantic)
5600             pedwarn ("ISO C89 forbids specifying element to initialize");
5601
5602           constructor_range_end = last ? convert (bitsizetype, last) : 0;
5603         }
5604     }
5605 }
5606
5607 /* Within a struct initializer, specify the next field to be initialized.  */
5608
5609 void
5610 set_init_label (fieldname)
5611      tree fieldname;
5612 {
5613   tree tail;
5614   int passed = 0;
5615
5616   /* Don't die if an entire brace-pair level is superfluous
5617      in the containing level.  */
5618   if (constructor_type == 0)
5619     return;
5620
5621   for (tail = TYPE_FIELDS (constructor_type); tail;
5622        tail = TREE_CHAIN (tail))
5623     {
5624       if (tail == constructor_unfilled_fields)
5625         passed = 1;
5626       if (DECL_NAME (tail) == fieldname)
5627         break;
5628     }
5629
5630   if (tail == 0)
5631     error ("unknown field `%s' specified in initializer",
5632            IDENTIFIER_POINTER (fieldname));
5633   else if (!passed)
5634     error ("field `%s' already initialized",
5635            IDENTIFIER_POINTER (fieldname));
5636   else
5637     {
5638       constructor_fields = tail;
5639       if (pedantic)
5640         pedwarn ("ISO C89 forbids specifying structure member to initialize");
5641     }
5642 }
5643 \f
5644 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5645    indentifies the initializer, either array index or field in a structure.
5646    VALUE is the value of that index or field.  */
5647
5648 static void
5649 add_pending_init (purpose, value)
5650      tree purpose, value;
5651 {
5652   struct init_node *p, **q, *r;
5653
5654   q = &constructor_pending_elts;
5655   p = 0;
5656
5657   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5658     {
5659       while (*q != 0)
5660         {
5661           p = *q;
5662           if (tree_int_cst_lt (purpose, p->purpose))
5663             q = &p->left;
5664           else if (p->purpose != purpose)
5665             q = &p->right;
5666           else
5667             abort ();
5668         }
5669     }
5670   else
5671     {
5672       while (*q != NULL)
5673         {
5674           p = *q;
5675           if (tree_int_cst_lt (bit_position (purpose),
5676                                bit_position (p->purpose)))
5677             q = &p->left;
5678           else if (p->purpose != purpose)
5679             q = &p->right;
5680           else
5681             abort ();
5682         }
5683     }
5684
5685   r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5686   r->purpose = purpose;
5687   r->value = value;
5688
5689   *q = r;
5690   r->parent = p;
5691   r->left = 0;
5692   r->right = 0;
5693   r->balance = 0;
5694
5695   while (p)
5696     {
5697       struct init_node *s;
5698
5699       if (r == p->left)
5700         {
5701           if (p->balance == 0)
5702             p->balance = -1;
5703           else if (p->balance < 0)
5704             {
5705               if (r->balance < 0)
5706                 {
5707                   /* L rotation. */
5708                   p->left = r->right;
5709                   if (p->left)
5710                     p->left->parent = p;
5711                   r->right = p;
5712
5713                   p->balance = 0;
5714                   r->balance = 0;
5715
5716                   s = p->parent;
5717                   p->parent = r;
5718                   r->parent = s;
5719                   if (s)
5720                     {
5721                       if (s->left == p)
5722                         s->left = r;
5723                       else
5724                         s->right = r;
5725                     }
5726                   else
5727                     constructor_pending_elts = r;
5728                 }
5729               else
5730                 {
5731                   /* LR rotation. */
5732                   struct init_node *t = r->right;
5733
5734                   r->right = t->left;
5735                   if (r->right)
5736                     r->right->parent = r;
5737                   t->left = r;
5738
5739                   p->left = t->right;
5740                   if (p->left)
5741                     p->left->parent = p;
5742                   t->right = p;
5743
5744                   p->balance = t->balance < 0;
5745                   r->balance = -(t->balance > 0);
5746                   t->balance = 0;
5747
5748                   s = p->parent;
5749                   p->parent = t;
5750                   r->parent = t;
5751                   t->parent = s;
5752                   if (s)
5753                     {
5754                       if (s->left == p)
5755                         s->left = t;
5756                       else
5757                         s->right = t;
5758                     }
5759                   else
5760                     constructor_pending_elts = t;
5761                 }
5762               break;
5763             }
5764           else
5765             {
5766               /* p->balance == +1; growth of left side balances the node.  */
5767               p->balance = 0;
5768               break;
5769             }
5770         }
5771       else /* r == p->right */
5772         {
5773           if (p->balance == 0)
5774             /* Growth propagation from right side.  */
5775             p->balance++;
5776           else if (p->balance > 0)
5777             {
5778               if (r->balance > 0)
5779                 {
5780                   /* R rotation. */
5781                   p->right = r->left;
5782                   if (p->right)
5783                     p->right->parent = p;
5784                   r->left = p;
5785
5786                   p->balance = 0;
5787                   r->balance = 0;
5788
5789                   s = p->parent;
5790                   p->parent = r;
5791                   r->parent = s;
5792                   if (s)
5793                     {
5794                       if (s->left == p)
5795                         s->left = r;
5796                       else
5797                         s->right = r;
5798                     }
5799                   else
5800                     constructor_pending_elts = r;
5801                 }
5802               else /* r->balance == -1 */
5803                 {
5804                   /* RL rotation */
5805                   struct init_node *t = r->left;
5806
5807                   r->left = t->right;
5808                   if (r->left)
5809                     r->left->parent = r;
5810                   t->right = r;
5811
5812                   p->right = t->left;
5813                   if (p->right)
5814                     p->right->parent = p;
5815                   t->left = p;
5816
5817                   r->balance = (t->balance < 0);
5818                   p->balance = -(t->balance > 0);
5819                   t->balance = 0;
5820
5821                   s = p->parent;
5822                   p->parent = t;
5823                   r->parent = t;
5824                   t->parent = s;
5825                   if (s)
5826                     {
5827                       if (s->left == p)
5828                         s->left = t;
5829                       else
5830                         s->right = t;
5831                     }
5832                   else
5833                     constructor_pending_elts = t;
5834                 }
5835               break;
5836             }
5837           else
5838             {
5839               /* p->balance == -1; growth of right side balances the node. */
5840               p->balance = 0;
5841               break;
5842             }
5843         }
5844
5845       r = p;
5846       p = p->parent;
5847     }
5848 }
5849
5850 /* Return nonzero if FIELD is equal to the index of a pending initializer.  */
5851
5852 static int
5853 pending_init_member (field)
5854      tree field;
5855 {
5856   struct init_node *p;
5857
5858   p = constructor_pending_elts;
5859   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5860     {
5861       while (p)
5862         {
5863           if (field == p->purpose)
5864             return 1;
5865           else if (tree_int_cst_lt (field, p->purpose))
5866             p = p->left;
5867           else
5868             p = p->right;
5869         }
5870     }
5871   else
5872     {
5873       while (p)
5874         {
5875           if (field == p->purpose)
5876             return 1;
5877           else if (tree_int_cst_lt (bit_position (field),
5878                                     bit_position (p->purpose)))
5879             p = p->left;
5880           else
5881             p = p->right;
5882         }
5883     }
5884
5885   return 0;
5886 }
5887
5888 /* "Output" the next constructor element.
5889    At top level, really output it to assembler code now.
5890    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5891    TYPE is the data type that the containing data type wants here.
5892    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5893
5894    PENDING if non-nil means output pending elements that belong
5895    right after this element.  (PENDING is normally 1;
5896    it is 0 while outputting pending elements, to avoid recursion.)  */
5897
5898 static void
5899 output_init_element (value, type, field, pending)
5900      tree value, type, field;
5901      int pending;
5902 {
5903   int duplicate = 0;
5904
5905   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5906       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5907           && !(TREE_CODE (value) == STRING_CST
5908                && TREE_CODE (type) == ARRAY_TYPE
5909                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5910           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5911                          TYPE_MAIN_VARIANT (type))))
5912     value = default_conversion (value);
5913
5914   if (value == error_mark_node)
5915     constructor_erroneous = 1;
5916   else if (!TREE_CONSTANT (value))
5917     constructor_constant = 0;
5918   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5919            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5920                 || TREE_CODE (constructor_type) == UNION_TYPE)
5921                && DECL_C_BIT_FIELD (field)
5922                && TREE_CODE (value) != INTEGER_CST))
5923     constructor_simple = 0;
5924
5925   if (require_constant_value && ! TREE_CONSTANT (value))
5926     {
5927       error_init ("initializer element is not constant");
5928       value = error_mark_node;
5929     }
5930   else if (require_constant_elements
5931            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5932     {
5933       error_init ("initializer element is not computable at load time");
5934       value = error_mark_node;
5935     }
5936
5937   /* If this element duplicates one on constructor_pending_elts,
5938      print a message and ignore it.  Don't do this when we're
5939      processing elements taken off constructor_pending_elts,
5940      because we'd always get spurious errors.  */
5941   if (pending)
5942     {
5943       if (TREE_CODE (constructor_type) == RECORD_TYPE
5944           || TREE_CODE (constructor_type) == UNION_TYPE
5945           || TREE_CODE (constructor_type) == ARRAY_TYPE)
5946         {
5947           if (pending_init_member (field))
5948             {
5949               error_init ("duplicate initializer");
5950               duplicate = 1;
5951             }
5952         }
5953     }
5954
5955   /* If this element doesn't come next in sequence,
5956      put it on constructor_pending_elts.  */
5957   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5958       && ! tree_int_cst_equal (field, constructor_unfilled_index))
5959     {
5960       if (! duplicate)
5961         add_pending_init (field,
5962                           digest_init (type, value, require_constant_value,
5963                                        require_constant_elements));
5964     }
5965   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5966            && field != constructor_unfilled_fields)
5967     {
5968       /* We do this for records but not for unions.  In a union,
5969          no matter which field is specified, it can be initialized
5970          right away since it starts at the beginning of the union.  */
5971       if (!duplicate)
5972         add_pending_init (field,
5973                           digest_init (type, value, require_constant_value,
5974                                        require_constant_elements));
5975     }
5976   else
5977     {
5978       /* Otherwise, output this element either to
5979          constructor_elements or to the assembler file.  */
5980
5981       if (!duplicate)
5982         {
5983           if (! constructor_incremental)
5984             {
5985               if (field && TREE_CODE (field) == INTEGER_CST)
5986                 field = copy_node (field);
5987               constructor_elements
5988                 = tree_cons (field, digest_init (type, value,
5989                                                  require_constant_value,
5990                                                  require_constant_elements),
5991                              constructor_elements);
5992             }
5993           else
5994             {
5995               /* Structure elements may require alignment.
5996                  Do this, if necessary.  */
5997               if (TREE_CODE (constructor_type) == RECORD_TYPE
5998                   && ! tree_int_cst_equal (constructor_bit_index,
5999                                            bit_position (field)))
6000                 /* Advance to offset of this element.  */
6001                 assemble_zeros
6002                   (tree_low_cst
6003                    (size_binop (TRUNC_DIV_EXPR,
6004                                 size_binop (MINUS_EXPR, bit_position (field),
6005                                             constructor_bit_index),
6006                                 bitsize_unit_node),
6007                     0));
6008
6009               output_constant (digest_init (type, value,
6010                                             require_constant_value,
6011                                             require_constant_elements),
6012                                int_size_in_bytes (type));
6013
6014               /* For a record or union,
6015                  keep track of end position of last field.  */
6016               if (TREE_CODE (constructor_type) == RECORD_TYPE
6017                   || TREE_CODE (constructor_type) == UNION_TYPE)
6018                 constructor_bit_index
6019                   = size_binop (PLUS_EXPR, bit_position (field),
6020                                 DECL_SIZE (field));
6021             }
6022         }
6023
6024       /* Advance the variable that indicates sequential elements output.  */
6025       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6026         constructor_unfilled_index
6027           = size_binop (PLUS_EXPR, constructor_unfilled_index,
6028                         bitsize_one_node);
6029       else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6030         {
6031           constructor_unfilled_fields
6032             = TREE_CHAIN (constructor_unfilled_fields);
6033
6034           /* Skip any nameless bit fields.  */
6035           while (constructor_unfilled_fields != 0
6036                  && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6037                  && DECL_NAME (constructor_unfilled_fields) == 0)
6038             constructor_unfilled_fields =
6039               TREE_CHAIN (constructor_unfilled_fields);
6040         }
6041       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6042         constructor_unfilled_fields = 0;
6043
6044       /* Now output any pending elements which have become next.  */
6045       if (pending)
6046         output_pending_init_elements (0);
6047     }
6048 }
6049
6050 /* Output any pending elements which have become next.
6051    As we output elements, constructor_unfilled_{fields,index}
6052    advances, which may cause other elements to become next;
6053    if so, they too are output.
6054
6055    If ALL is 0, we return when there are
6056    no more pending elements to output now.
6057
6058    If ALL is 1, we output space as necessary so that
6059    we can output all the pending elements.  */
6060
6061 static void
6062 output_pending_init_elements (all)
6063      int all;
6064 {
6065   struct init_node *elt = constructor_pending_elts;
6066   tree next;
6067
6068  retry:
6069
6070   /* Look thru the whole pending tree.
6071      If we find an element that should be output now,
6072      output it.  Otherwise, set NEXT to the element
6073      that comes first among those still pending.  */
6074
6075   next = 0;
6076   while (elt)
6077     {
6078       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6079         {
6080           if (tree_int_cst_equal (elt->purpose,
6081                                   constructor_unfilled_index))
6082             output_init_element (elt->value,
6083                                  TREE_TYPE (constructor_type),
6084                                  constructor_unfilled_index, 0);
6085           else if (tree_int_cst_lt (constructor_unfilled_index,
6086                                     elt->purpose))
6087             {
6088               /* Advance to the next smaller node.  */
6089               if (elt->left)
6090                 elt = elt->left;
6091               else
6092                 {
6093                   /* We have reached the smallest node bigger than the
6094                      current unfilled index.  Fill the space first.  */
6095                   next = elt->purpose;
6096                   break;
6097                 }
6098             }
6099           else
6100             {
6101               /* Advance to the next bigger node.  */
6102               if (elt->right)
6103                 elt = elt->right;
6104               else
6105                 {
6106                   /* We have reached the biggest node in a subtree.  Find
6107                      the parent of it, which is the next bigger node.  */
6108                   while (elt->parent && elt->parent->right == elt)
6109                     elt = elt->parent;
6110                   elt = elt->parent;
6111                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6112                                               elt->purpose))
6113                     {
6114                       next = elt->purpose;
6115                       break;
6116                     }
6117                 }
6118             }
6119         }
6120       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6121                || TREE_CODE (constructor_type) == UNION_TYPE)
6122         {
6123           /* If the current record is complete we are done.  */
6124           if (constructor_unfilled_fields == 0)
6125             break;
6126           if (elt->purpose == constructor_unfilled_fields)
6127             {
6128               output_init_element (elt->value,
6129                                    TREE_TYPE (constructor_unfilled_fields),
6130                                    constructor_unfilled_fields,
6131                                    0);
6132             }
6133           else if (tree_int_cst_lt (bit_position (constructor_unfilled_fields),
6134                                     bit_position (elt->purpose)))
6135             {
6136               /* Advance to the next smaller node.  */
6137               if (elt->left)
6138                 elt = elt->left;
6139               else
6140                 {
6141                   /* We have reached the smallest node bigger than the
6142                      current unfilled field.  Fill the space first.  */
6143                   next = elt->purpose;
6144                   break;
6145                 }
6146             }
6147           else
6148             {
6149               /* Advance to the next bigger node.  */
6150               if (elt->right)
6151                 elt = elt->right;
6152               else
6153                 {
6154                   /* We have reached the biggest node in a subtree.  Find
6155                      the parent of it, which is the next bigger node.  */
6156                   while (elt->parent && elt->parent->right == elt)
6157                     elt = elt->parent;
6158                   elt = elt->parent;
6159                   if (elt
6160                       && (tree_int_cst_lt
6161                           (bit_position (constructor_unfilled_fields),
6162                            bit_position (elt->purpose))))
6163                     {
6164                       next = elt->purpose;
6165                       break;
6166                     }
6167                 }
6168             }
6169         }
6170     }
6171
6172   /* Ordinarily return, but not if we want to output all
6173      and there are elements left.  */
6174   if (! (all && next != 0))
6175     return;
6176
6177   /* Generate space up to the position of NEXT.  */
6178   if (constructor_incremental)
6179     {
6180       tree filled;
6181       tree nextpos_tree = bitsize_zero_node;
6182
6183       if (TREE_CODE (constructor_type) == RECORD_TYPE
6184           || TREE_CODE (constructor_type) == UNION_TYPE)
6185         {
6186           tree tail;
6187
6188           /* Find the last field written out, if any.  */
6189           for (tail = TYPE_FIELDS (constructor_type); tail;
6190                tail = TREE_CHAIN (tail))
6191             if (TREE_CHAIN (tail) == constructor_unfilled_fields)
6192               break;
6193
6194           if (tail)
6195             /* Find the offset of the end of that field.  */
6196             filled = size_binop (CEIL_DIV_EXPR,
6197                                  size_binop (PLUS_EXPR, bit_position (tail),
6198                                              DECL_SIZE (tail)),
6199                                  bitsize_unit_node);
6200           else
6201             filled = bitsize_zero_node;
6202
6203           nextpos_tree = convert (bitsizetype, byte_position (next));
6204           constructor_bit_index = bit_position (next);
6205           constructor_unfilled_fields = next;
6206         }
6207       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6208         {
6209           filled
6210             = size_binop (MULT_EXPR, constructor_unfilled_index,
6211                           convert (bitsizetype,
6212                                    TYPE_SIZE_UNIT
6213                                    (TREE_TYPE (constructor_type))));
6214           nextpos_tree
6215             = size_binop (MULT_EXPR, next,
6216                           convert (bitsizetype, TYPE_SIZE_UNIT
6217                                    (TREE_TYPE (constructor_type))));
6218           constructor_unfilled_index = next;
6219         }
6220       else
6221         filled = 0;
6222
6223       if (filled)
6224         assemble_zeros (tree_low_cst (size_diffop (nextpos_tree, filled), 1));
6225     }
6226   else
6227     {
6228       /* If it's not incremental, just skip over the gap,
6229          so that after jumping to retry we will output the next
6230          successive element.  */
6231       if (TREE_CODE (constructor_type) == RECORD_TYPE
6232           || TREE_CODE (constructor_type) == UNION_TYPE)
6233         constructor_unfilled_fields = next;
6234       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6235         constructor_unfilled_index = next;
6236     }
6237
6238   /* ELT now points to the node in the pending tree with the next
6239      initializer to output.  */
6240   goto retry;
6241 }
6242 \f
6243 /* Add one non-braced element to the current constructor level.
6244    This adjusts the current position within the constructor's type.
6245    This may also start or terminate implicit levels
6246    to handle a partly-braced initializer.
6247
6248    Once this has found the correct level for the new element,
6249    it calls output_init_element.
6250
6251    Note: if we are incrementally outputting this constructor,
6252    this function may be called with a null argument
6253    representing a sub-constructor that was already incrementally output.
6254    When that happens, we output nothing, but we do the bookkeeping
6255    to skip past that element of the current constructor.  */
6256
6257 void
6258 process_init_element (value)
6259      tree value;
6260 {
6261   tree orig_value = value;
6262   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6263
6264   /* Handle superfluous braces around string cst as in
6265      char x[] = {"foo"}; */
6266   if (string_flag
6267       && constructor_type
6268       && TREE_CODE (constructor_type) == ARRAY_TYPE
6269       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6270       && integer_zerop (constructor_unfilled_index))
6271     {
6272       if (constructor_stack->replacement_value)
6273         error_init ("excess elements in char array initializer");
6274       constructor_stack->replacement_value = value;
6275       return;
6276     }
6277
6278   if (constructor_stack->replacement_value != 0)
6279     {
6280       error_init ("excess elements in struct initializer");
6281       return;
6282     }
6283
6284   /* Ignore elements of a brace group if it is entirely superfluous
6285      and has already been diagnosed.  */
6286   if (constructor_type == 0)
6287     return;
6288
6289   /* If we've exhausted any levels that didn't have braces,
6290      pop them now.  */
6291   while (constructor_stack->implicit)
6292     {
6293       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6294            || TREE_CODE (constructor_type) == UNION_TYPE)
6295           && constructor_fields == 0)
6296         process_init_element (pop_init_level (1));
6297       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6298                && (constructor_max_index == 0
6299                    || tree_int_cst_lt (constructor_max_index,
6300                                        constructor_index)))
6301         process_init_element (pop_init_level (1));
6302       else
6303         break;
6304     }
6305
6306   while (1)
6307     {
6308       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6309         {
6310           tree fieldtype;
6311           enum tree_code fieldcode;
6312
6313           if (constructor_fields == 0)
6314             {
6315               pedwarn_init ("excess elements in struct initializer");
6316               break;
6317             }
6318
6319           fieldtype = TREE_TYPE (constructor_fields);
6320           if (fieldtype != error_mark_node)
6321             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6322           fieldcode = TREE_CODE (fieldtype);
6323
6324           /* Accept a string constant to initialize a subarray.  */
6325           if (value != 0
6326               && fieldcode == ARRAY_TYPE
6327               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6328               && string_flag)
6329             value = orig_value;
6330           /* Otherwise, if we have come to a subaggregate,
6331              and we don't have an element of its type, push into it.  */
6332           else if (value != 0 && !constructor_no_implicit
6333                    && value != error_mark_node
6334                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6335                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6336                        || fieldcode == UNION_TYPE))
6337             {
6338               push_init_level (1);
6339               continue;
6340             }
6341
6342           if (value)
6343             {
6344               push_member_name (constructor_fields);
6345               output_init_element (value, fieldtype, constructor_fields, 1);
6346               RESTORE_SPELLING_DEPTH (constructor_depth);
6347             }
6348           else
6349             /* Do the bookkeeping for an element that was
6350                directly output as a constructor.  */
6351             {
6352               /* For a record, keep track of end position of last field.  */
6353               constructor_bit_index
6354                 = size_binop (PLUS_EXPR,
6355                               bit_position (constructor_fields),
6356                               DECL_SIZE (constructor_fields));
6357
6358               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6359               /* Skip any nameless bit fields.  */
6360               while (constructor_unfilled_fields != 0
6361                      && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6362                      && DECL_NAME (constructor_unfilled_fields) == 0)
6363                 constructor_unfilled_fields =
6364                   TREE_CHAIN (constructor_unfilled_fields);
6365             }
6366
6367           constructor_fields = TREE_CHAIN (constructor_fields);
6368           /* Skip any nameless bit fields at the beginning.  */
6369           while (constructor_fields != 0
6370                  && DECL_C_BIT_FIELD (constructor_fields)
6371                  && DECL_NAME (constructor_fields) == 0)
6372             constructor_fields = TREE_CHAIN (constructor_fields);
6373           break;
6374         }
6375       if (TREE_CODE (constructor_type) == UNION_TYPE)
6376         {
6377           tree fieldtype;
6378           enum tree_code fieldcode;
6379
6380           if (constructor_fields == 0)
6381             {
6382               pedwarn_init ("excess elements in union initializer");
6383               break;
6384             }
6385
6386           fieldtype = TREE_TYPE (constructor_fields);
6387           if (fieldtype != error_mark_node)
6388             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6389           fieldcode = TREE_CODE (fieldtype);
6390
6391           /* Warn that traditional C rejects initialization of unions.
6392              We skip the warning if the value is zero.  This is done
6393              under the assumption that the zero initializer in user
6394              code appears conditioned on e.g. __STDC__ to avoid
6395              "missing initializer" warnings and relies on default
6396              initialization to zero in the traditional C case.  */
6397           if (warn_traditional && !in_system_header
6398               && !(value && (integer_zerop (value) || real_zerop (value))))
6399             warning ("traditional C rejects initialization of unions");
6400
6401           /* Accept a string constant to initialize a subarray.  */
6402           if (value != 0
6403               && fieldcode == ARRAY_TYPE
6404               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6405               && string_flag)
6406             value = orig_value;
6407           /* Otherwise, if we have come to a subaggregate,
6408              and we don't have an element of its type, push into it.  */
6409           else if (value != 0 && !constructor_no_implicit
6410                    && value != error_mark_node
6411                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6412                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6413                        || fieldcode == UNION_TYPE))
6414             {
6415               push_init_level (1);
6416               continue;
6417             }
6418
6419           if (value)
6420             {
6421               push_member_name (constructor_fields);
6422               output_init_element (value, fieldtype, constructor_fields, 1);
6423               RESTORE_SPELLING_DEPTH (constructor_depth);
6424             }
6425           else
6426             /* Do the bookkeeping for an element that was
6427                directly output as a constructor.  */
6428             {
6429               constructor_bit_index = DECL_SIZE (constructor_fields);
6430               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6431             }
6432
6433           constructor_fields = 0;
6434           break;
6435         }
6436       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6437         {
6438           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6439           enum tree_code eltcode = TREE_CODE (elttype);
6440
6441           /* Accept a string constant to initialize a subarray.  */
6442           if (value != 0
6443               && eltcode == ARRAY_TYPE
6444               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6445               && string_flag)
6446             value = orig_value;
6447           /* Otherwise, if we have come to a subaggregate,
6448              and we don't have an element of its type, push into it.  */
6449           else if (value != 0 && !constructor_no_implicit
6450                    && value != error_mark_node
6451                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6452                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6453                        || eltcode == UNION_TYPE))
6454             {
6455               push_init_level (1);
6456               continue;
6457             }
6458
6459           if (constructor_max_index != 0
6460               && tree_int_cst_lt (constructor_max_index, constructor_index))
6461             {
6462               pedwarn_init ("excess elements in array initializer");
6463               break;
6464             }
6465
6466           /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once.  */
6467           if (constructor_range_end)
6468             {
6469               if (constructor_max_index != 0
6470                   && tree_int_cst_lt (constructor_max_index,
6471                                       constructor_range_end))
6472                 {
6473                   pedwarn_init ("excess elements in array initializer");
6474                   constructor_range_end = constructor_max_index;
6475                 }
6476
6477               value = save_expr (value);
6478             }
6479
6480           /* Now output the actual element.
6481              Ordinarily, output once.
6482              If there is a range, repeat it till we advance past the range.  */
6483           do
6484             {
6485               if (value)
6486                 {
6487                   push_array_bounds (tree_low_cst (constructor_index, 0));
6488                   output_init_element (value, elttype, constructor_index, 1);
6489                   RESTORE_SPELLING_DEPTH (constructor_depth);
6490                 }
6491
6492               constructor_index
6493                 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6494
6495               if (! value)
6496                 /* If we are doing the bookkeeping for an element that was
6497                    directly output as a constructor, we must update
6498                    constructor_unfilled_index.  */
6499                 constructor_unfilled_index = constructor_index;
6500             }
6501           while (! (constructor_range_end == 0
6502                     || tree_int_cst_lt (constructor_range_end,
6503                                         constructor_index)));
6504
6505           break;
6506         }
6507
6508       /* Handle the sole element allowed in a braced initializer
6509          for a scalar variable.  */
6510       if (constructor_fields == 0)
6511         {
6512           pedwarn_init ("excess elements in scalar initializer");
6513           break;
6514         }
6515
6516       if (value)
6517         output_init_element (value, constructor_type, NULL_TREE, 1);
6518       constructor_fields = 0;
6519       break;
6520     }
6521 }
6522 \f
6523 /* Expand an ASM statement with operands, handling output operands
6524    that are not variables or INDIRECT_REFS by transforming such
6525    cases into cases that expand_asm_operands can handle.
6526
6527    Arguments are same as for expand_asm_operands.  */
6528
6529 void
6530 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6531      tree string, outputs, inputs, clobbers;
6532      int vol;
6533      const char *filename;
6534      int line;
6535 {
6536   int noutputs = list_length (outputs);
6537   register int i;
6538   /* o[I] is the place that output number I should be written.  */
6539   register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6540   register tree tail;
6541
6542   if (TREE_CODE (string) == ADDR_EXPR)
6543     string = TREE_OPERAND (string, 0);
6544   if (TREE_CODE (string) != STRING_CST)
6545     {
6546       error ("asm template is not a string constant");
6547       return;
6548     }
6549
6550   /* Record the contents of OUTPUTS before it is modified.  */
6551   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6552     {
6553       tree output = TREE_VALUE (tail);
6554
6555       /* We can remove conversions that just change the type, not the mode.  */
6556       STRIP_NOPS (output);
6557       o[i] = output;
6558
6559       /* Allow conversions as LHS here.  build_modify_expr as called below
6560          will do the right thing with them.  */
6561       while (TREE_CODE (output) == NOP_EXPR
6562              || TREE_CODE (output) == CONVERT_EXPR
6563              || TREE_CODE (output) == FLOAT_EXPR
6564              || TREE_CODE (output) == FIX_TRUNC_EXPR
6565              || TREE_CODE (output) == FIX_FLOOR_EXPR
6566              || TREE_CODE (output) == FIX_ROUND_EXPR
6567              || TREE_CODE (output) == FIX_CEIL_EXPR)
6568         output = TREE_OPERAND (output, 0);
6569
6570       lvalue_or_else (o[i], "invalid lvalue in asm statement");
6571     }
6572
6573   /* Perform default conversions on array and function inputs.  */
6574   /* Don't do this for other types--
6575      it would screw up operands expected to be in memory.  */
6576   for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
6577     if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6578         || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6579       TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6580
6581   /* Generate the ASM_OPERANDS insn;
6582      store into the TREE_VALUEs of OUTPUTS some trees for
6583      where the values were actually stored.  */
6584   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6585
6586   /* Copy all the intermediate outputs into the specified outputs.  */
6587   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6588     {
6589       if (o[i] != TREE_VALUE (tail))
6590         {
6591           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6592                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6593           free_temp_slots ();
6594         }
6595       /* Detect modification of read-only values.
6596          (Otherwise done by build_modify_expr.)  */
6597       else
6598         {
6599           tree type = TREE_TYPE (o[i]);
6600           if (TREE_READONLY (o[i])
6601               || TYPE_READONLY (type)
6602               || ((TREE_CODE (type) == RECORD_TYPE
6603                    || TREE_CODE (type) == UNION_TYPE)
6604                   && C_TYPE_FIELDS_READONLY (type)))
6605             readonly_warning (o[i], "modification by `asm'");
6606         }
6607     }
6608
6609   /* Those MODIFY_EXPRs could do autoincrements.  */
6610   emit_queue ();
6611 }
6612 \f
6613 /* Expand a C `return' statement.
6614    RETVAL is the expression for what to return,
6615    or a null pointer for `return;' with no value.  */
6616
6617 void
6618 c_expand_return (retval)
6619      tree retval;
6620 {
6621   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6622
6623   if (TREE_THIS_VOLATILE (current_function_decl))
6624     warning ("function declared `noreturn' has a `return' statement");
6625
6626   if (!retval)
6627     {
6628       current_function_returns_null = 1;
6629       if ((warn_return_type || flag_isoc99)
6630           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6631         pedwarn_c99 ("`return' with no value, in function returning non-void");
6632     }
6633   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6634     {
6635       current_function_returns_null = 1;
6636       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6637         pedwarn ("`return' with a value, in function returning void");
6638     }
6639   else
6640     {
6641       tree t = convert_for_assignment (valtype, retval, _("return"),
6642                                        NULL_TREE, NULL_TREE, 0);
6643       tree res = DECL_RESULT (current_function_decl);
6644       tree inner;
6645
6646       if (t == error_mark_node)
6647         return;
6648
6649       inner = t = convert (TREE_TYPE (res), t);
6650
6651       /* Strip any conversions, additions, and subtractions, and see if
6652          we are returning the address of a local variable.  Warn if so.  */
6653       while (1)
6654         {
6655           switch (TREE_CODE (inner))
6656             {
6657             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6658             case PLUS_EXPR:
6659               inner = TREE_OPERAND (inner, 0);
6660               continue;
6661
6662             case MINUS_EXPR:
6663               /* If the second operand of the MINUS_EXPR has a pointer
6664                  type (or is converted from it), this may be valid, so
6665                  don't give a warning.  */
6666               {
6667                 tree op1 = TREE_OPERAND (inner, 1);
6668
6669                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6670                        && (TREE_CODE (op1) == NOP_EXPR
6671                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6672                            || TREE_CODE (op1) == CONVERT_EXPR))
6673                   op1 = TREE_OPERAND (op1, 0);
6674
6675                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6676                   break;
6677
6678                 inner = TREE_OPERAND (inner, 0);
6679                 continue;
6680               }
6681
6682             case ADDR_EXPR:
6683               inner = TREE_OPERAND (inner, 0);
6684
6685               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6686                 inner = TREE_OPERAND (inner, 0);
6687
6688               if (TREE_CODE (inner) == VAR_DECL
6689                   && ! DECL_EXTERNAL (inner)
6690                   && ! TREE_STATIC (inner)
6691                   && DECL_CONTEXT (inner) == current_function_decl)
6692                 warning ("function returns address of local variable");
6693               break;
6694
6695             default:
6696               break;
6697             }
6698
6699           break;
6700         }
6701
6702       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6703       current_function_returns_value = 1;
6704     }
6705
6706   genrtl_return_stmt (build_return_stmt (retval));
6707 }
6708 \f
6709 /* Start a C switch statement, testing expression EXP.
6710    Return EXP if it is valid, an error node otherwise.  */
6711
6712 tree
6713 c_expand_start_case (exp)
6714      tree exp;
6715 {
6716   register enum tree_code code;
6717   tree type;
6718
6719   if (TREE_CODE (exp) == ERROR_MARK)
6720     return exp;
6721
6722   code = TREE_CODE (TREE_TYPE (exp));
6723   type = TREE_TYPE (exp);
6724
6725   if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
6726     {
6727       error ("switch quantity not an integer");
6728       exp = error_mark_node;
6729     }
6730   else
6731     {
6732       tree index;
6733       type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6734
6735       if (warn_traditional && !in_system_header
6736           && (type == long_integer_type_node
6737               || type == long_unsigned_type_node))
6738         warning ("`long' switch expression not converted to `int' in ISO C");
6739
6740       exp = default_conversion (exp);
6741       type = TREE_TYPE (exp);
6742       index = get_unwidened (exp, NULL_TREE);
6743       /* We can't strip a conversion from a signed type to an unsigned,
6744          because if we did, int_fits_type_p would do the wrong thing
6745          when checking case values for being in range,
6746          and it's too hard to do the right thing.  */
6747       if (TREE_UNSIGNED (TREE_TYPE (exp))
6748           == TREE_UNSIGNED (TREE_TYPE (index)))
6749         exp = index;
6750     }
6751
6752   expand_start_case (1, exp, type, "switch statement");
6753
6754   return exp;
6755 }