gcc/c-typeck.c

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