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