gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992 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 #include "config.h"
  21 #include "tree.h"
  22 #include "c-lex.h"
  23 #include "c-tree.h"
  24 #include "flags.h"
  25 #include "obstack.h"
  26 #include <stdio.h>
  27
  28 extern struct obstack permanent_obstack;
  29
  30 /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
  31
  32 void
  33 declare_function_name ()
  34 {
  35   tree decl, type, init;
  36   char *name, *printable_name;
  37   int len;
  38
  39   if (current_function_decl == NULL)
  40     {
  41       name = "";
  42       printable_name = "top level";
  43     }
  44   else
  45     {
  46       char *kind = "function";
  47       if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
  48         kind = "method";
  49       /* Allow functions to be nameless (such as artificial ones).  */
  50       if (DECL_NAME (current_function_decl))
  51         name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
  52       else
  53         name = "";
  54       printable_name = (*decl_printable_name) (current_function_decl, &kind);
  55     }
  56
  57   /* If the default size of char arrays isn't big enough for the name,
  58      make a bigger one.  */
  59   len = strlen (name) + 1;
  60   type = char_array_type_node;
  61   if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (char_array_type_node)))
  62       < len)
  63     type = build_array_type (char_type_node,
  64                              build_index_type (build_int_2 (len, 0)));
  65
  66   push_obstacks_nochange ();
  67   decl = build_decl (VAR_DECL, get_identifier ("__FUNCTION__"), type);
  68   TREE_STATIC (decl) = 1;
  69   TREE_READONLY (decl) = 1;
  70   DECL_SOURCE_LINE (decl) = 0;
  71   DECL_IN_SYSTEM_HEADER (decl) = 1;
  72   DECL_IGNORED_P (decl) = 1;
  73   init = build_string (len, name);
  74   TREE_TYPE (init) = type;
  75   DECL_INITIAL (decl) = init;
  76   finish_decl (pushdecl (decl), init, NULL_TREE);
  77
  78   len = strlen (printable_name) + 1;
  79   type = char_array_type_node;
  80   if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (char_array_type_node)))
  81       < len)
  82     type = build_array_type (char_type_node,
  83                              build_index_type (build_int_2 (len, 0)));
  84
  85   push_obstacks_nochange ();
  86   decl = build_decl (VAR_DECL, get_identifier ("__PRETTY_FUNCTION__"), type);
  87   TREE_STATIC (decl) = 1;
  88   TREE_READONLY (decl) = 1;
  89   DECL_SOURCE_LINE (decl) = 0;
  90   DECL_IN_SYSTEM_HEADER (decl) = 1;
  91   DECL_IGNORED_P (decl) = 1;
  92   init = build_string (len, printable_name);
  93   TREE_TYPE (init) = type;
  94   DECL_INITIAL (decl) = init;
  95   finish_decl (pushdecl (decl), init, NULL_TREE);
  96 }
  97
  98 /* Given a chain of STRING_CST nodes,
  99    concatenate them into one STRING_CST
 100    and give it a suitable array-of-chars data type.  */
 101
 102 tree
 103 combine_strings (strings)
 104      tree strings;
 105 {
 106   register tree value, t;
 107   register int length = 1;
 108   int wide_length = 0;
 109   int wide_flag = 0;
 110   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 111   int nchars;
 112
 113   if (TREE_CHAIN (strings))
 114     {
 115       /* More than one in the chain, so concatenate.  */
 116       register char *p, *q;
 117
 118       /* Don't include the \0 at the end of each substring,
 119          except for the last one.
 120          Count wide strings and ordinary strings separately.  */
 121       for (t = strings; t; t = TREE_CHAIN (t))
 122         {
 123           if (TREE_TYPE (t) == wchar_array_type_node)
 124             {
 125               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 126               wide_flag = 1;
 127             }
 128           else
 129             length += (TREE_STRING_LENGTH (t) - 1);
 130         }
 131
 132       /* If anything is wide, the non-wides will be converted,
 133          which makes them take more space.  */
 134       if (wide_flag)
 135         length = length * wchar_bytes + wide_length;
 136
 137       p = savealloc (length);
 138
 139       /* Copy the individual strings into the new combined string.
 140          If the combined string is wide, convert the chars to ints
 141          for any individual strings that are not wide.  */
 142
 143       q = p;
 144       for (t = strings; t; t = TREE_CHAIN (t))
 145         {
 146           int len = (TREE_STRING_LENGTH (t)
 147                      - ((TREE_TYPE (t) == wchar_array_type_node)
 148                         ? wchar_bytes : 1));
 149           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 150             {
 151               bcopy (TREE_STRING_POINTER (t), q, len);
 152               q += len;
 153             }
 154           else
 155             {
 156               int i;
 157               for (i = 0; i < len; i++)
 158                 ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
 159               q += len * wchar_bytes;
 160             }
 161         }
 162       if (wide_flag)
 163         {
 164           int i;
 165           for (i = 0; i < wchar_bytes; i++)
 166             *q++ = 0;
 167         }
 168       else
 169         *q = 0;
 170
 171       value = make_node (STRING_CST);
 172       TREE_STRING_POINTER (value) = p;
 173       TREE_STRING_LENGTH (value) = length;
 174       TREE_CONSTANT (value) = 1;
 175     }
 176   else
 177     {
 178       value = strings;
 179       length = TREE_STRING_LENGTH (value);
 180       if (TREE_TYPE (value) == wchar_array_type_node)
 181         wide_flag = 1;
 182     }
 183
 184   /* Compute the number of elements, for the array type.  */
 185   nchars = wide_flag ? length / wchar_bytes : length;
 186
 187   /* Create the array type for the string constant.
 188      -Wwrite-strings says make the string constant an array of const char
 189      so that copying it to a non-const pointer will get a warning.  */
 190   if (warn_write_strings
 191       && (! flag_traditional  && ! flag_writable_strings))
 192     {
 193       tree elements
 194         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 195                               1, 0);
 196       TREE_TYPE (value)
 197         = build_array_type (elements,
 198                             build_index_type (build_int_2 (nchars - 1, 0)));
 199     }
 200   else
 201     TREE_TYPE (value)
 202       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 203                           build_index_type (build_int_2 (nchars - 1, 0)));
 204   TREE_CONSTANT (value) = 1;
 205   TREE_STATIC (value) = 1;
 206   return value;
 207 }
 208 \f
 209 /* Process the attributes listed in ATTRIBUTES
 210    and install them in DECL.  */
 211
 212 void
 213 decl_attributes (decl, attributes)
 214      tree decl, attributes;
 215 {
 216   tree a;
 217   for (a = attributes; a; a = TREE_CHAIN (a))
 218     if (TREE_VALUE (a) == get_identifier ("packed"))
 219       {
 220         if (TREE_CODE (decl) == FIELD_DECL)
 221           DECL_PACKED (decl) = 1;
 222         /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 223            used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
 224       }
 225     else if (TREE_VALUE (a) != 0
 226              && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
 227              && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("mode"))
 228       {
 229         int i;
 230         char *specified_name
 231           = IDENTIFIER_POINTER (TREE_VALUE (TREE_VALUE (a)));
 232
 233         /* Give this decl a type with the specified mode.  */
 234         for (i = 0; i < NUM_MACHINE_MODES; i++)
 235           if (!strcmp (specified_name, GET_MODE_NAME (i)))
 236             {
 237               tree type
 238                 = type_for_mode (i, TREE_UNSIGNED (TREE_TYPE (decl)));
 239               if (type != 0)
 240                 {
 241                   TREE_TYPE (decl) = type;
 242                   DECL_SIZE (decl) = 0;
 243                   layout_decl (decl, 0);
 244                 }
 245               else
 246                 error ("no data type for mode `%s'", specified_name);
 247               break;
 248             }
 249         if (i == NUM_MACHINE_MODES)
 250           error ("unknown machine mode `%s'", specified_name);
 251       }
 252     else if (TREE_VALUE (a) != 0
 253              && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
 254              && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("aligned"))
 255       {
 256         int align = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (a)))
 257                     * BITS_PER_UNIT;
 258
 259         if (exact_log2 (align) == -1)
 260           error_with_decl (decl,
 261                            "requested alignment of `%s' is not a power of 2");
 262         else if (TREE_CODE (decl) != VAR_DECL
 263                  && TREE_CODE (decl) != FIELD_DECL)
 264           error_with_decl (decl,
 265                            "alignment specified for `%s'");
 266         else
 267           DECL_ALIGN (decl) = align;
 268       }
 269     else if (TREE_VALUE (a) != 0
 270              && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
 271              && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("format"))
 272       {
 273         tree list = TREE_VALUE (TREE_VALUE (a));
 274         tree format_type = TREE_PURPOSE (list);
 275         int format_num = TREE_INT_CST_LOW (TREE_PURPOSE (TREE_VALUE (list)));
 276         int first_arg_num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list)));
 277         int is_scan;
 278         tree argument;
 279         int arg_num;
 280
 281         if (TREE_CODE (decl) != FUNCTION_DECL)
 282           {
 283             error_with_decl (decl,
 284                              "argument format specified for non-function `%s'");
 285             return;
 286           }
 287
 288         if (format_type == get_identifier ("printf"))
 289           is_scan = 0;
 290         else if (format_type == get_identifier ("scanf"))
 291           is_scan = 1;
 292         else
 293           {
 294             error_with_decl (decl, "unrecognized format specifier for `%s'");
 295             return;
 296           }
 297
 298         if (first_arg_num != 0 && first_arg_num <= format_num)
 299           {
 300             error_with_decl (decl,
 301                 "format string arg follows the args to be formatted, for `%s'");
 302             return;
 303           }
 304
 305         /* Verify that the format_num argument is actually a string, in case
 306            the format attribute is in error.  */
 307         argument = TYPE_ARG_TYPES (TREE_TYPE (decl));
 308         for (arg_num = 1; ; ++arg_num)
 309           {
 310             if (argument == 0 || arg_num == format_num)
 311               break;
 312             argument = TREE_CHAIN (argument);
 313           }
 314         if (! argument
 315             || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 316             || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 317                 != char_type_node))
 318           {
 319             error_with_decl (decl,
 320                              "format string arg not a string type, for `%s'");
 321             return;
 322           }
 323         /* Verify that first_arg_num points to the last argument, the ... */
 324         while (argument)
 325           arg_num++, argument = TREE_CHAIN (argument);
 326         if (arg_num != first_arg_num)
 327           {
 328             error_with_decl (decl,
 329                              "args to be formatted is not ..., for `%s'");
 330             return;
 331           }
 332
 333         record_format_info (DECL_NAME (decl), is_scan, format_num,
 334                             first_arg_num);
 335       }
 336 }
 337 \f
 338 /* Print a warning if a constant expression had overflow in folding.
 339    Invoke this function on every expression that the language
 340    requires to be a constant expression.
 341    Note the ANSI C standard says it is erroneous for a
 342    constant expression to overflow.  */
 343
 344 void
 345 constant_expression_warning (value)
 346      tree value;
 347 {
 348   if (TREE_CODE (value) == INTEGER_CST && TREE_CONSTANT_OVERFLOW (value))
 349     {
 350       pedwarn ("overflow in constant expression");
 351       /* Suppress duplicate warnings.  */
 352       TREE_CONSTANT_OVERFLOW (value) = 0;
 353     }
 354 }
 355
 356 /* Print a warning if an expression had overflow in folding.
 357    Invoke this function on every expression that
 358    (1) appears in the source code, and
 359    (2) might be a constant expression that overflowed, and
 360    (3) is not already checked by convert_and_check;
 361    however, do not invoke this function on operands of explicit casts.  */
 362
 363 void
 364 overflow_warning (value)
 365      tree value;
 366 {
 367   if (TREE_CODE (value) == INTEGER_CST && TREE_CONSTANT_OVERFLOW (value))
 368     {
 369       pedwarn ("integer overflow in expression");
 370       TREE_CONSTANT_OVERFLOW (value) = 0;
 371     }
 372 }
 373
 374 /* Print a warning if a large constant is truncated to unsigned,
 375    or if -Wconversion is used and a constant < 0 is converted to unsigned.
 376    Invoke this function on every expression that might be implicitly
 377    converted to an unsigned type.  */
 378
 379 void
 380 unsigned_conversion_warning (result, operand)
 381      tree result, operand;
 382 {
 383   if (TREE_CODE (operand) == INTEGER_CST
 384       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
 385       && TREE_UNSIGNED (TREE_TYPE (result))
 386       && !int_fits_type_p (operand, TREE_TYPE (result)))
 387     {
 388       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
 389         /* This detects cases like converting -129 or 256 to unsigned char.  */
 390         pedwarn ("large integer implicitly truncated to unsigned type");
 391       else if (warn_conversion)
 392         pedwarn ("negative integer implicitly converted to unsigned type");
 393     }
 394 }
 395
 396 /* Convert EXPR to TYPE, warning about conversion problems with constants.
 397    Invoke this function on every expression that is converted implicitly,
 398    i.e. because of language rules and not because of an explicit cast.  */
 399
 400 tree
 401 convert_and_check (type, expr)
 402      tree type, expr;
 403 {
 404   tree t = convert (type, expr);
 405   if (TREE_CODE (t) == INTEGER_CST)
 406     {
 407       if (TREE_UNSIGNED (TREE_TYPE (expr))
 408           && !TREE_UNSIGNED (type)
 409           && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
 410           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr)))
 411         /* No warning for converting 0x80000000 to int.  */
 412         TREE_CONSTANT_OVERFLOW (t) = 0;
 413       else if (TREE_CONSTANT_OVERFLOW (t))
 414         {
 415           pedwarn ("overflow in implicit constant conversion");
 416           TREE_CONSTANT_OVERFLOW (t) = 0;
 417         }
 418       else
 419         unsigned_conversion_warning (t, expr);
 420     }
 421   return t;
 422 }
 423 \f
 424 void
 425 c_expand_expr_stmt (expr)
 426      tree expr;
 427 {
 428   /* Do default conversion if safe and possibly important,
 429      in case within ({...}).  */
 430   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
 431       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
 432     expr = default_conversion (expr);
 433
 434   if (TREE_TYPE (expr) != error_mark_node
 435       && TYPE_SIZE (TREE_TYPE (expr)) == 0
 436       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
 437     error ("expression statement has incomplete type");
 438
 439   expand_expr_stmt (expr);
 440 }
 441 \f
 442 /* Validate the expression after `case' and apply default promotions.  */
 443
 444 tree
 445 check_case_value (value)
 446      tree value;
 447 {
 448   if (value == NULL_TREE)
 449     return value;
 450
 451   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
 452   STRIP_TYPE_NOPS (value);
 453
 454   if (TREE_CODE (value) != INTEGER_CST
 455       && value != error_mark_node)
 456     {
 457       error ("case label does not reduce to an integer constant");
 458       value = error_mark_node;
 459     }
 460   else
 461     /* Promote char or short to int.  */
 462     value = default_conversion (value);
 463
 464   constant_expression_warning (value);
 465
 466   return value;
 467 }
 468 \f
 469 /* Return an integer type with BITS bits of precision,
 470    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
 471
 472 tree
 473 type_for_size (bits, unsignedp)
 474      unsigned bits;
 475      int unsignedp;
 476 {
 477   if (bits == TYPE_PRECISION (signed_char_type_node))
 478     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 479
 480   if (bits == TYPE_PRECISION (short_integer_type_node))
 481     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 482
 483   if (bits == TYPE_PRECISION (integer_type_node))
 484     return unsignedp ? unsigned_type_node : integer_type_node;
 485
 486   if (bits == TYPE_PRECISION (long_integer_type_node))
 487     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 488
 489   if (bits == TYPE_PRECISION (long_long_integer_type_node))
 490     return (unsignedp ? long_long_unsigned_type_node
 491             : long_long_integer_type_node);
 492
 493   if (bits <= TYPE_PRECISION (intQI_type_node))
 494     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
 495
 496   if (bits <= TYPE_PRECISION (intHI_type_node))
 497     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
 498
 499   if (bits <= TYPE_PRECISION (intSI_type_node))
 500     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
 501
 502   if (bits <= TYPE_PRECISION (intDI_type_node))
 503     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
 504
 505   return 0;
 506 }
 507
 508 /* Return a data type that has machine mode MODE.
 509    If the mode is an integer,
 510    then UNSIGNEDP selects between signed and unsigned types.  */
 511
 512 tree
 513 type_for_mode (mode, unsignedp)
 514      enum machine_mode mode;
 515      int unsignedp;
 516 {
 517   if (mode == TYPE_MODE (signed_char_type_node))
 518     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 519
 520   if (mode == TYPE_MODE (short_integer_type_node))
 521     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 522
 523   if (mode == TYPE_MODE (integer_type_node))
 524     return unsignedp ? unsigned_type_node : integer_type_node;
 525
 526   if (mode == TYPE_MODE (long_integer_type_node))
 527     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 528
 529   if (mode == TYPE_MODE (long_long_integer_type_node))
 530     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
 531
 532   if (mode == TYPE_MODE (intQI_type_node))
 533     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
 534
 535   if (mode == TYPE_MODE (intHI_type_node))
 536     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
 537
 538   if (mode == TYPE_MODE (intSI_type_node))
 539     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
 540
 541   if (mode == TYPE_MODE (intDI_type_node))
 542     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
 543
 544   if (mode == TYPE_MODE (float_type_node))
 545     return float_type_node;
 546
 547   if (mode == TYPE_MODE (double_type_node))
 548     return double_type_node;
 549
 550   if (mode == TYPE_MODE (long_double_type_node))
 551     return long_double_type_node;
 552
 553   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
 554     return build_pointer_type (char_type_node);
 555
 556   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
 557     return build_pointer_type (integer_type_node);
 558
 559   return 0;
 560 }
 561 \f
 562 /* Print an error message for invalid operands to arith operation CODE.
 563    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
 564
 565 void
 566 binary_op_error (code)
 567      enum tree_code code;
 568 {
 569   register char *opname;
 570   switch (code)
 571     {
 572     case NOP_EXPR:
 573       error ("invalid truth-value expression");
 574       return;
 575
 576     case PLUS_EXPR:
 577       opname = "+"; break;
 578     case MINUS_EXPR:
 579       opname = "-"; break;
 580     case MULT_EXPR:
 581       opname = "*"; break;
 582     case MAX_EXPR:
 583       opname = "max"; break;
 584     case MIN_EXPR:
 585       opname = "min"; break;
 586     case EQ_EXPR:
 587       opname = "=="; break;
 588     case NE_EXPR:
 589       opname = "!="; break;
 590     case LE_EXPR:
 591       opname = "<="; break;
 592     case GE_EXPR:
 593       opname = ">="; break;
 594     case LT_EXPR:
 595       opname = "<"; break;
 596     case GT_EXPR:
 597       opname = ">"; break;
 598     case LSHIFT_EXPR:
 599       opname = "<<"; break;
 600     case RSHIFT_EXPR:
 601       opname = ">>"; break;
 602     case TRUNC_MOD_EXPR:
 603     case FLOOR_MOD_EXPR:
 604       opname = "%"; break;
 605     case TRUNC_DIV_EXPR:
 606     case FLOOR_DIV_EXPR:
 607       opname = "/"; break;
 608     case BIT_AND_EXPR:
 609       opname = "&"; break;
 610     case BIT_IOR_EXPR:
 611       opname = "|"; break;
 612     case TRUTH_ANDIF_EXPR:
 613       opname = "&&"; break;
 614     case TRUTH_ORIF_EXPR:
 615       opname = "||"; break;
 616     case BIT_XOR_EXPR:
 617       opname = "^"; break;
 618     case LROTATE_EXPR:
 619     case RROTATE_EXPR:
 620       opname = "rotate"; break;
 621     }
 622   error ("invalid operands to binary %s", opname);
 623 }
 624 \f
 625 /* Subroutine of build_binary_op, used for comparison operations.
 626    See if the operands have both been converted from subword integer types
 627    and, if so, perhaps change them both back to their original type.
 628
 629    The arguments of this function are all pointers to local variables
 630    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
 631    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
 632
 633    If this function returns nonzero, it means that the comparison has
 634    a constant value.  What this function returns is an expression for
 635    that value.  */
 636
 637 tree
 638 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
 639      tree *op0_ptr, *op1_ptr;
 640      tree *restype_ptr;
 641      enum tree_code *rescode_ptr;
 642 {
 643   register tree type;
 644   tree op0 = *op0_ptr;
 645   tree op1 = *op1_ptr;
 646   int unsignedp0, unsignedp1;
 647   int real1, real2;
 648   tree primop0, primop1;
 649   enum tree_code code = *rescode_ptr;
 650
 651   /* Throw away any conversions to wider types
 652      already present in the operands.  */
 653
 654   primop0 = get_narrower (op0, &unsignedp0);
 655   primop1 = get_narrower (op1, &unsignedp1);
 656
 657   /* Handle the case that OP0 does not *contain* a conversion
 658      but it *requires* conversion to FINAL_TYPE.  */
 659
 660   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
 661     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
 662   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
 663     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
 664
 665   /* If one of the operands must be floated, we cannot optimize.  */
 666   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
 667   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
 668
 669   /* If first arg is constant, swap the args (changing operation
 670      so value is preserved), for canonicalization.  */
 671
 672   if (TREE_CONSTANT (primop0))
 673     {
 674       register tree tem = primop0;
 675       register int temi = unsignedp0;
 676       primop0 = primop1;
 677       primop1 = tem;
 678       tem = op0;
 679       op0 = op1;
 680       op1 = tem;
 681       *op0_ptr = op0;
 682       *op1_ptr = op1;
 683       unsignedp0 = unsignedp1;
 684       unsignedp1 = temi;
 685       temi = real1;
 686       real1 = real2;
 687       real2 = temi;
 688
 689       switch (code)
 690         {
 691         case LT_EXPR:
 692           code = GT_EXPR;
 693           break;
 694         case GT_EXPR:
 695           code = LT_EXPR;
 696           break;
 697         case LE_EXPR:
 698           code = GE_EXPR;
 699           break;
 700         case GE_EXPR:
 701           code = LE_EXPR;
 702           break;
 703         }
 704       *rescode_ptr = code;
 705     }
 706
 707   /* If comparing an integer against a constant more bits wide,
 708      maybe we can deduce a value of 1 or 0 independent of the data.
 709      Or else truncate the constant now
 710      rather than extend the variable at run time.
 711
 712      This is only interesting if the constant is the wider arg.
 713      Also, it is not safe if the constant is unsigned and the
 714      variable arg is signed, since in this case the variable
 715      would be sign-extended and then regarded as unsigned.
 716      Our technique fails in this case because the lowest/highest
 717      possible unsigned results don't follow naturally from the
 718      lowest/highest possible values of the variable operand.
 719      For just EQ_EXPR and NE_EXPR there is another technique that
 720      could be used: see if the constant can be faithfully represented
 721      in the other operand's type, by truncating it and reextending it
 722      and see if that preserves the constant's value.  */
 723
 724   if (!real1 && !real2
 725       && TREE_CODE (primop1) == INTEGER_CST
 726       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
 727     {
 728       int min_gt, max_gt, min_lt, max_lt;
 729       tree maxval, minval;
 730       /* 1 if comparison is nominally unsigned.  */
 731       int unsignedp = TREE_UNSIGNED (*restype_ptr);
 732       tree val;
 733
 734       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
 735
 736       maxval = TYPE_MAX_VALUE (type);
 737       minval = TYPE_MIN_VALUE (type);
 738
 739       if (unsignedp && !unsignedp0)
 740         *restype_ptr = signed_type (*restype_ptr);
 741
 742       if (TREE_TYPE (primop1) != *restype_ptr)
 743         primop1 = convert (*restype_ptr, primop1);
 744       if (type != *restype_ptr)
 745         {
 746           minval = convert (*restype_ptr, minval);
 747           maxval = convert (*restype_ptr, maxval);
 748         }
 749
 750       if (unsignedp && unsignedp0)
 751         {
 752           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
 753           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
 754           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
 755           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
 756         }
 757       else
 758         {
 759           min_gt = INT_CST_LT (primop1, minval);
 760           max_gt = INT_CST_LT (primop1, maxval);
 761           min_lt = INT_CST_LT (minval, primop1);
 762           max_lt = INT_CST_LT (maxval, primop1);
 763         }
 764
 765       val = 0;
 766       /* This used to be a switch, but Genix compiler can't handle that.  */
 767       if (code == NE_EXPR)
 768         {
 769           if (max_lt || min_gt)
 770             val = integer_one_node;
 771         }
 772       else if (code == EQ_EXPR)
 773         {
 774           if (max_lt || min_gt)
 775             val = integer_zero_node;
 776         }
 777       else if (code == LT_EXPR)
 778         {
 779           if (max_lt)
 780             val = integer_one_node;
 781           if (!min_lt)
 782             val = integer_zero_node;
 783         }
 784       else if (code == GT_EXPR)
 785         {
 786           if (min_gt)
 787             val = integer_one_node;
 788           if (!max_gt)
 789             val = integer_zero_node;
 790         }
 791       else if (code == LE_EXPR)
 792         {
 793           if (!max_gt)
 794             val = integer_one_node;
 795           if (min_gt)
 796             val = integer_zero_node;
 797         }
 798       else if (code == GE_EXPR)
 799         {
 800           if (!min_lt)
 801             val = integer_one_node;
 802           if (max_lt)
 803             val = integer_zero_node;
 804         }
 805
 806       /* If primop0 was sign-extended and unsigned comparison specd,
 807          we did a signed comparison above using the signed type bounds.
 808          But the comparison we output must be unsigned.
 809
 810          Also, for inequalities, VAL is no good; but if the signed
 811          comparison had *any* fixed result, it follows that the
 812          unsigned comparison just tests the sign in reverse
 813          (positive values are LE, negative ones GE).
 814          So we can generate an unsigned comparison
 815          against an extreme value of the signed type.  */
 816
 817       if (unsignedp && !unsignedp0)
 818         {
 819           if (val != 0)
 820             switch (code)
 821               {
 822               case LT_EXPR:
 823               case GE_EXPR:
 824                 primop1 = TYPE_MIN_VALUE (type);
 825                 val = 0;
 826                 break;
 827
 828               case LE_EXPR:
 829               case GT_EXPR:
 830                 primop1 = TYPE_MAX_VALUE (type);
 831                 val = 0;
 832                 break;
 833               }
 834           type = unsigned_type (type);
 835         }
 836
 837       if (!max_gt && !unsignedp0)
 838         {
 839           /* This is the case of (char)x >?< 0x80, which people used to use
 840              expecting old C compilers to change the 0x80 into -0x80.  */
 841           if (val == integer_zero_node)
 842             warning ("comparison is always 0 due to limited range of data type");
 843           if (val == integer_one_node)
 844             warning ("comparison is always 1 due to limited range of data type");
 845         }
 846
 847       if (!min_lt && unsignedp0)
 848         {
 849           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
 850           if (val == integer_zero_node)
 851             warning ("comparison is always 0 due to limited range of data type");
 852           if (val == integer_one_node)
 853             warning ("comparison is always 1 due to limited range of data type");
 854         }
 855
 856       if (val != 0)
 857         {
 858           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
 859           if (TREE_SIDE_EFFECTS (primop0))
 860             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
 861           return val;
 862         }
 863
 864       /* Value is not predetermined, but do the comparison
 865          in the type of the operand that is not constant.
 866          TYPE is already properly set.  */
 867     }
 868   else if (real1 && real2
 869            && (TYPE_PRECISION (TREE_TYPE (primop0))
 870                == TYPE_PRECISION (TREE_TYPE (primop1))))
 871     type = TREE_TYPE (primop0);
 872
 873   /* If args' natural types are both narrower than nominal type
 874      and both extend in the same manner, compare them
 875      in the type of the wider arg.
 876      Otherwise must actually extend both to the nominal
 877      common type lest different ways of extending
 878      alter the result.
 879      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
 880
 881   else if (unsignedp0 == unsignedp1 && real1 == real2
 882            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
 883            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
 884     {
 885       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
 886       type = signed_or_unsigned_type (unsignedp0
 887                                       || TREE_UNSIGNED (*restype_ptr),
 888                                       type);
 889       /* Make sure shorter operand is extended the right way
 890          to match the longer operand.  */
 891       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
 892                          primop0);
 893       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
 894                          primop1);
 895     }
 896   else
 897     {
 898       /* Here we must do the comparison on the nominal type
 899          using the args exactly as we received them.  */
 900       type = *restype_ptr;
 901       primop0 = op0;
 902       primop1 = op1;
 903
 904       if (!real1 && !real2 && integer_zerop (primop1)
 905           && TREE_UNSIGNED (TREE_TYPE (primop0)))
 906         {
 907           tree value = 0;
 908           switch (code)
 909             {
 910             case GE_EXPR:
 911               if (extra_warnings)
 912                 warning ("unsigned value >= 0 is always 1");
 913               value = integer_one_node;
 914               break;
 915
 916             case LT_EXPR:
 917               if (extra_warnings)
 918                 warning ("unsigned value < 0 is always 0");
 919               value = integer_zero_node;
 920             }
 921
 922           if (value != 0)
 923             {
 924               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
 925               if (TREE_SIDE_EFFECTS (primop0))
 926                 return build (COMPOUND_EXPR, TREE_TYPE (value),
 927                               primop0, value);
 928               return value;
 929             }
 930         }
 931     }
 932
 933   *op0_ptr = convert (type, primop0);
 934   *op1_ptr = convert (type, primop1);
 935
 936   *restype_ptr = integer_type_node;
 937
 938   return 0;
 939 }
 940 \f
 941 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
 942    or validate its data type for an `if' or `while' statement or ?..: exp.
 943
 944    This preparation consists of taking the ordinary
 945    representation of an expression expr and producing a valid tree
 946    boolean expression describing whether expr is nonzero.  We could
 947    simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
 948    but we optimize comparisons, &&, ||, and !.
 949
 950    The resulting type should always be `integer_type_node'.  */
 951
 952 tree
 953 truthvalue_conversion (expr)
 954      tree expr;
 955 {
 956   register enum tree_code code;
 957
 958   if (TREE_CODE (expr) == ERROR_MARK)
 959     return expr;
 960
 961   /* These really should return error_mark_node after 2.4 is stable.
 962      But not all callers handle ERROR_MARK properly.  */
 963   switch (TREE_CODE (TREE_TYPE (expr)))
 964     {
 965     case RECORD_TYPE:
 966       error ("struct type value used where scalar is required");
 967       return integer_zero_node;
 968
 969     case UNION_TYPE:
 970       error ("union type value used where scalar is required");
 971       return integer_zero_node;
 972
 973     case ARRAY_TYPE:
 974       error ("array type value used where scalar is required");
 975       return integer_zero_node;
 976
 977     default:
 978       break;
 979     }
 980
 981   switch (TREE_CODE (expr))
 982     {
 983       /* It is simpler and generates better code to have only TRUTH_*_EXPR
 984          or comparison expressions as truth values at this level.  */
 985 #if 0
 986     case COMPONENT_REF:
 987       /* A one-bit unsigned bit-field is already acceptable.  */
 988       if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
 989           && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
 990         return expr;
 991       break;
 992 #endif
 993
 994     case EQ_EXPR:
 995       /* It is simpler and generates better code to have only TRUTH_*_EXPR
 996          or comparison expressions as truth values at this level.  */
 997 #if 0
 998       if (integer_zerop (TREE_OPERAND (expr, 1)))
 999         return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
1000 #endif
1001     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
1002     case TRUTH_ANDIF_EXPR:
1003     case TRUTH_ORIF_EXPR:
1004     case TRUTH_AND_EXPR:
1005     case TRUTH_OR_EXPR:
1006     case TRUTH_XOR_EXPR:
1007     case ERROR_MARK:
1008       return expr;
1009
1010     case INTEGER_CST:
1011       return integer_zerop (expr) ? integer_zero_node : integer_one_node;
1012
1013     case REAL_CST:
1014       return real_zerop (expr) ? integer_zero_node : integer_one_node;
1015
1016     case ADDR_EXPR:
1017       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
1018         return build (COMPOUND_EXPR, integer_type_node,
1019                       TREE_OPERAND (expr, 0), integer_one_node);
1020       else
1021         return integer_one_node;
1022
1023     case COMPLEX_EXPR:
1024       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
1025                                ? TRUTH_AND_EXPR : TRUTH_ANDIF_EXPR),
1026                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
1027                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
1028                               0);
1029
1030     case NEGATE_EXPR:
1031     case ABS_EXPR:
1032     case FLOAT_EXPR:
1033     case FFS_EXPR:
1034       /* These don't change whether an object is non-zero or zero.  */
1035       return truthvalue_conversion (TREE_OPERAND (expr, 0));
1036
1037     case LROTATE_EXPR:
1038     case RROTATE_EXPR:
1039       /* These don't change whether an object is zero or non-zero, but
1040          we can't ignore them if their second arg has side-effects.  */
1041       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
1042         return build (COMPOUND_EXPR, integer_type_node, TREE_OPERAND (expr, 1),
1043                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
1044       else
1045         return truthvalue_conversion (TREE_OPERAND (expr, 0));
1046
1047     case COND_EXPR:
1048       /* Distribute the conversion into the arms of a COND_EXPR.  */
1049       return fold (build (COND_EXPR, integer_type_node, TREE_OPERAND (expr, 0),
1050                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
1051                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
1052
1053     case CONVERT_EXPR:
1054       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
1055          since that affects how `default_conversion' will behave.  */
1056       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
1057           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
1058         break;
1059       /* fall through... */
1060     case NOP_EXPR:
1061       /* If this is widening the argument, we can ignore it.  */
1062       if (TYPE_PRECISION (TREE_TYPE (expr))
1063           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
1064         return truthvalue_conversion (TREE_OPERAND (expr, 0));
1065       break;
1066
1067     case BIT_XOR_EXPR:
1068     case MINUS_EXPR:
1069       /* These can be changed into a comparison of the two objects.  */
1070       if (TREE_TYPE (TREE_OPERAND (expr, 0))
1071           == TREE_TYPE (TREE_OPERAND (expr, 1)))
1072         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
1073                                 TREE_OPERAND (expr, 1), 1);
1074       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
1075                               fold (build1 (NOP_EXPR,
1076                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
1077                                             TREE_OPERAND (expr, 1))), 1);
1078
1079     case MODIFY_EXPR:
1080       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
1081         warning ("suggest parentheses around assignment used as truth value");
1082       break;
1083     }
1084
1085   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
1086     return (build_binary_op
1087             ((TREE_SIDE_EFFECTS (expr)
1088               ? TRUTH_AND_EXPR : TRUTH_ANDIF_EXPR),
1089              truthvalue_conversion (build_unary_op (REALPART_EXPR, expr, 0)),
1090              truthvalue_conversion (build_unary_op (IMAGPART_EXPR, expr, 0)),
1091              0));
1092
1093   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
1094 }
1095 \f
1096 /* Read the rest of a #-directive from input stream FINPUT.
1097    In normal use, the directive name and the white space after it
1098    have already been read, so they won't be included in the result.
1099    We allow for the fact that the directive line may contain
1100    a newline embedded within a character or string literal which forms
1101    a part of the directive.
1102
1103    The value is a string in a reusable buffer.  It remains valid
1104    only until the next time this function is called.  */
1105
1106 char *
1107 get_directive_line (finput)
1108      register FILE *finput;
1109 {
1110   static char *directive_buffer = NULL;
1111   static unsigned buffer_length = 0;
1112   register char *p;
1113   register char *buffer_limit;
1114   register int looking_for = 0;
1115   register int char_escaped = 0;
1116
1117   if (buffer_length == 0)
1118     {
1119       directive_buffer = (char *)xmalloc (128);
1120       buffer_length = 128;
1121     }
1122
1123   buffer_limit = &directive_buffer[buffer_length];
1124
1125   for (p = directive_buffer; ; )
1126     {
1127       int c;
1128
1129       /* Make buffer bigger if it is full.  */
1130       if (p >= buffer_limit)
1131         {
1132           register unsigned bytes_used = (p - directive_buffer);
1133
1134           buffer_length *= 2;
1135           directive_buffer
1136             = (char *)xrealloc (directive_buffer, buffer_length);
1137           p = &directive_buffer[bytes_used];
1138           buffer_limit = &directive_buffer[buffer_length];
1139         }
1140
1141       c = getc (finput);
1142
1143       /* Discard initial whitespace.  */
1144       if ((c == ' ' || c == '\t') && p == directive_buffer)
1145         continue;
1146
1147       /* Detect the end of the directive.  */
1148       if (c == '\n' && looking_for == 0)
1149         {
1150           ungetc (c, finput);
1151           c = '\0';
1152         }
1153
1154       *p++ = c;
1155
1156       if (c == 0)
1157         return directive_buffer;
1158
1159       /* Handle string and character constant syntax.  */
1160       if (looking_for)
1161         {
1162           if (looking_for == c && !char_escaped)
1163             looking_for = 0;    /* Found terminator... stop looking.  */
1164         }
1165       else
1166         if (c == '\'' || c == '"')
1167           looking_for = c;      /* Don't stop buffering until we see another
1168                                    another one of these (or an EOF).  */
1169
1170       /* Handle backslash.  */
1171       char_escaped = (c == '\\' && ! char_escaped);
1172     }
1173 }
1174 \f
1175 /* Make a variant type in the proper way for C/C++, propagating qualifiers
1176    down to the element type of an array.  */
1177
1178 tree
1179 c_build_type_variant (type, constp, volatilep)
1180      tree type;
1181      int constp, volatilep;
1182 {
1183   if (TREE_CODE (type) == ARRAY_TYPE)
1184     {
1185       tree real_main_variant = TYPE_MAIN_VARIANT (type);
1186       int permanent = TREE_PERMANENT (type);
1187
1188       if (permanent)
1189         push_obstacks (&permanent_obstack, &permanent_obstack);
1190       type = build_array_type (c_build_type_variant (TREE_TYPE (type),
1191                                                      constp, volatilep),
1192                                TYPE_DOMAIN (type));
1193       TYPE_MAIN_VARIANT (type) = real_main_variant;
1194       if (permanent)
1195         pop_obstacks ();
1196     }
1197   return build_type_variant (type, constp, volatilep);
1198 }