gcc/c-typeck.c

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