gcc/c-typeck.c

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