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