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