gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992, 93-98, 1999 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, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "tree.h"
  24 #include "c-lex.h"
  25 #include "c-tree.h"
  26 #include "flags.h"
  27 #include "obstack.h"
  28 #include "toplev.h"
  29 #include "output.h"
  30 #include "c-pragma.h"
  31 #include "rtl.h"
  32
  33 #if USE_CPPLIB
  34 #include "cpplib.h"
  35 cpp_reader  parse_in;
  36 cpp_options parse_options;
  37 static enum cpp_token cpp_token;
  38 #endif
  39
  40 #ifndef WCHAR_TYPE_SIZE
  41 #ifdef INT_TYPE_SIZE
  42 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  43 #else
  44 #define WCHAR_TYPE_SIZE BITS_PER_WORD
  45 #endif
  46 #endif
  47
  48 extern struct obstack permanent_obstack;
  49
  50 /* Nonzero means the expression being parsed will never be evaluated.
  51    This is a count, since unevaluated expressions can nest.  */
  52 int skip_evaluation;
  53
  54 enum attrs {A_PACKED, A_NOCOMMON, A_COMMON, A_NORETURN, A_CONST, A_T_UNION,
  55             A_NO_CHECK_MEMORY_USAGE, A_NO_INSTRUMENT_FUNCTION,
  56             A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED,
  57             A_UNUSED, A_FORMAT, A_FORMAT_ARG, A_WEAK, A_ALIAS,
  58             A_INIT_PRIORITY};
  59
  60 enum format_type { printf_format_type, scanf_format_type,
  61                    strftime_format_type };
  62
  63 static void declare_hidden_char_array   PROTO((char *, char *));
  64 static void add_attribute               PROTO((enum attrs, char *,
  65                                                int, int, int));
  66 static void init_attributes             PROTO((void));
  67 static void record_function_format      PROTO((tree, tree, enum format_type,
  68                                                int, int));
  69 static void record_international_format PROTO((tree, tree, int));
  70 static tree c_find_base_decl            PROTO((tree));
  71
  72 /* Keep a stack of if statements.  We record the number of compound
  73    statements seen up to the if keyword, as well as the line number
  74    and file of the if.  If a potentially ambiguous else is seen, that
  75    fact is recorded; the warning is issued when we can be sure that
  76    the enclosing if statement does not have an else branch.  */
  77 typedef struct
  78 {
  79   int compstmt_count;
  80   int line;
  81   char *file;
  82   int needs_warning;
  83 } if_elt;
  84
  85 static if_elt *if_stack;
  86
  87 /* Amount of space in the if statement stack.  */
  88 static int if_stack_space = 0;
  89
  90 /* Stack pointer.  */
  91 static int if_stack_pointer = 0;
  92
  93 /* Generate RTL for the start of an if-then, and record the start of it
  94    for ambiguous else detection.  */
  95
  96 /* A list of objects which have constructors or destructors which
  97    reside in the global scope, and have an init_priority attribute
  98    associated with them.  The decl is stored in the TREE_VALUE slot
  99    and the priority number is stored in the TREE_PURPOSE slot.  */
 100 tree static_aggregates_initp;
 101
 102 void
 103 c_expand_start_cond (cond, exitflag, compstmt_count)
 104      tree cond;
 105      int exitflag;
 106      int compstmt_count;
 107 {
 108   /* Make sure there is enough space on the stack.  */
 109   if (if_stack_space == 0)
 110     {
 111       if_stack_space = 10;
 112       if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
 113     }
 114   else if (if_stack_space == if_stack_pointer)
 115     {
 116       if_stack_space += 10;
 117       if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 118     }
 119
 120   /* Record this if statement.  */
 121   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 122   if_stack[if_stack_pointer].file = input_filename;
 123   if_stack[if_stack_pointer].line = lineno;
 124   if_stack[if_stack_pointer].needs_warning = 0;
 125   if_stack_pointer++;
 126
 127   expand_start_cond (cond, exitflag);
 128 }
 129
 130 /* Generate RTL for the end of an if-then.  Optionally warn if a nested
 131    if statement had an ambiguous else clause.  */
 132
 133 void
 134 c_expand_end_cond ()
 135 {
 136   if_stack_pointer--;
 137   if (if_stack[if_stack_pointer].needs_warning)
 138     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 139                                 if_stack[if_stack_pointer].line,
 140                                 "suggest explicit braces to avoid ambiguous `else'");
 141   expand_end_cond ();
 142 }
 143
 144 /* Generate RTL between the then-clause and the else-clause
 145    of an if-then-else.  */
 146
 147 void
 148 c_expand_start_else ()
 149 {
 150   /* An ambiguous else warning must be generated for the enclosing if
 151      statement, unless we see an else branch for that one, too.  */
 152   if (warn_parentheses
 153       && if_stack_pointer > 1
 154       && (if_stack[if_stack_pointer - 1].compstmt_count
 155           == if_stack[if_stack_pointer - 2].compstmt_count))
 156     if_stack[if_stack_pointer - 2].needs_warning = 1;
 157
 158   /* Even if a nested if statement had an else branch, it can't be
 159      ambiguous if this one also has an else.  So don't warn in that
 160      case.  Also don't warn for any if statements nested in this else.  */
 161   if_stack[if_stack_pointer - 1].needs_warning = 0;
 162   if_stack[if_stack_pointer - 1].compstmt_count--;
 163
 164   expand_start_else ();
 165 }
 166
 167 /* Make bindings for __FUNCTION__, __PRETTY_FUNCTION__, and __func__.  */
 168
 169 void
 170 declare_function_name ()
 171 {
 172   char *name, *printable_name;
 173
 174   if (current_function_decl == NULL)
 175     {
 176       name = "";
 177       printable_name = "top level";
 178     }
 179   else
 180     {
 181       /* Allow functions to be nameless (such as artificial ones).  */
 182       if (DECL_NAME (current_function_decl))
 183         name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 184       else
 185         name = "";
 186       printable_name = (*decl_printable_name) (current_function_decl, 2);
 187     }
 188
 189   declare_hidden_char_array ("__FUNCTION__", name);
 190   declare_hidden_char_array ("__PRETTY_FUNCTION__", printable_name);
 191   /* The ISO C people "of course" couldn't use __FUNCTION__ in the
 192      ISO C 9x standard; instead a new variable is invented.  */
 193   declare_hidden_char_array ("__func__", name);
 194 }
 195
 196 static void
 197 declare_hidden_char_array (name, value)
 198      char *name, *value;
 199 {
 200   tree decl, type, init;
 201   int vlen;
 202
 203   /* If the default size of char arrays isn't big enough for the name,
 204      or if we want to give warnings for large objects, make a bigger one.  */
 205   vlen = strlen (value) + 1;
 206   type = char_array_type_node;
 207   if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < vlen
 208       || warn_larger_than)
 209     type = build_array_type (char_type_node,
 210                              build_index_type (build_int_2 (vlen, 0)));
 211   push_obstacks_nochange ();
 212   decl = build_decl (VAR_DECL, get_identifier (name), type);
 213   TREE_STATIC (decl) = 1;
 214   TREE_READONLY (decl) = 1;
 215   TREE_ASM_WRITTEN (decl) = 1;
 216   DECL_SOURCE_LINE (decl) = 0;
 217   DECL_ARTIFICIAL (decl) = 1;
 218   DECL_IN_SYSTEM_HEADER (decl) = 1;
 219   DECL_IGNORED_P (decl) = 1;
 220   init = build_string (vlen, value);
 221   TREE_TYPE (init) = type;
 222   DECL_INITIAL (decl) = init;
 223   finish_decl (pushdecl (decl), init, NULL_TREE);
 224 }
 225
 226 /* Given a chain of STRING_CST nodes,
 227    concatenate them into one STRING_CST
 228    and give it a suitable array-of-chars data type.  */
 229
 230 tree
 231 combine_strings (strings)
 232      tree strings;
 233 {
 234   register tree value, t;
 235   register int length = 1;
 236   int wide_length = 0;
 237   int wide_flag = 0;
 238   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 239   int nchars;
 240
 241   if (TREE_CHAIN (strings))
 242     {
 243       /* More than one in the chain, so concatenate.  */
 244       register char *p, *q;
 245
 246       /* Don't include the \0 at the end of each substring,
 247          except for the last one.
 248          Count wide strings and ordinary strings separately.  */
 249       for (t = strings; t; t = TREE_CHAIN (t))
 250         {
 251           if (TREE_TYPE (t) == wchar_array_type_node)
 252             {
 253               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 254               wide_flag = 1;
 255             }
 256           else
 257             length += (TREE_STRING_LENGTH (t) - 1);
 258         }
 259
 260       /* If anything is wide, the non-wides will be converted,
 261          which makes them take more space.  */
 262       if (wide_flag)
 263         length = length * wchar_bytes + wide_length;
 264
 265       p = savealloc (length);
 266
 267       /* Copy the individual strings into the new combined string.
 268          If the combined string is wide, convert the chars to ints
 269          for any individual strings that are not wide.  */
 270
 271       q = p;
 272       for (t = strings; t; t = TREE_CHAIN (t))
 273         {
 274           int len = (TREE_STRING_LENGTH (t)
 275                      - ((TREE_TYPE (t) == wchar_array_type_node)
 276                         ? wchar_bytes : 1));
 277           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 278             {
 279               memcpy (q, TREE_STRING_POINTER (t), len);
 280               q += len;
 281             }
 282           else
 283             {
 284               int i;
 285               for (i = 0; i < len; i++)
 286                 {
 287                   if (WCHAR_TYPE_SIZE == HOST_BITS_PER_SHORT)
 288                     ((short *) q)[i] = TREE_STRING_POINTER (t)[i];
 289                   else
 290                     ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
 291                 }
 292               q += len * wchar_bytes;
 293             }
 294         }
 295       if (wide_flag)
 296         {
 297           int i;
 298           for (i = 0; i < wchar_bytes; i++)
 299             *q++ = 0;
 300         }
 301       else
 302         *q = 0;
 303
 304       value = make_node (STRING_CST);
 305       TREE_STRING_POINTER (value) = p;
 306       TREE_STRING_LENGTH (value) = length;
 307     }
 308   else
 309     {
 310       value = strings;
 311       length = TREE_STRING_LENGTH (value);
 312       if (TREE_TYPE (value) == wchar_array_type_node)
 313         wide_flag = 1;
 314     }
 315
 316   /* Compute the number of elements, for the array type.  */
 317   nchars = wide_flag ? length / wchar_bytes : length;
 318
 319   /* Create the array type for the string constant.
 320      -Wwrite-strings says make the string constant an array of const char
 321      so that copying it to a non-const pointer will get a warning.
 322      For C++, this is the standard behavior.  */
 323   if (flag_const_strings
 324       && (! flag_traditional  && ! flag_writable_strings))
 325     {
 326       tree elements
 327         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 328                               1, 0);
 329       TREE_TYPE (value)
 330         = build_array_type (elements,
 331                             build_index_type (build_int_2 (nchars - 1, 0)));
 332     }
 333   else
 334     TREE_TYPE (value)
 335       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 336                           build_index_type (build_int_2 (nchars - 1, 0)));
 337
 338   TREE_READONLY (value) = TREE_CONSTANT (value) = ! flag_writable_strings;
 339   TREE_STATIC (value) = 1;
 340   return value;
 341 }
 342 \f
 343 /* To speed up processing of attributes, we maintain an array of
 344    IDENTIFIER_NODES and the corresponding attribute types.  */
 345
 346 /* Array to hold attribute information.  */
 347
 348 static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50];
 349
 350 static int attrtab_idx = 0;
 351
 352 /* Add an entry to the attribute table above.  */
 353
 354 static void
 355 add_attribute (id, string, min_len, max_len, decl_req)
 356      enum attrs id;
 357      char *string;
 358      int min_len, max_len;
 359      int decl_req;
 360 {
 361   char buf[100];
 362
 363   attrtab[attrtab_idx].id = id;
 364   attrtab[attrtab_idx].name = get_identifier (string);
 365   attrtab[attrtab_idx].min = min_len;
 366   attrtab[attrtab_idx].max = max_len;
 367   attrtab[attrtab_idx++].decl_req = decl_req;
 368
 369   sprintf (buf, "__%s__", string);
 370
 371   attrtab[attrtab_idx].id = id;
 372   attrtab[attrtab_idx].name = get_identifier (buf);
 373   attrtab[attrtab_idx].min = min_len;
 374   attrtab[attrtab_idx].max = max_len;
 375   attrtab[attrtab_idx++].decl_req = decl_req;
 376 }
 377
 378 /* Initialize attribute table.  */
 379
 380 static void
 381 init_attributes ()
 382 {
 383   add_attribute (A_PACKED, "packed", 0, 0, 0);
 384   add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1);
 385   add_attribute (A_COMMON, "common", 0, 0, 1);
 386   add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
 387   add_attribute (A_NORETURN, "volatile", 0, 0, 1);
 388   add_attribute (A_UNUSED, "unused", 0, 0, 0);
 389   add_attribute (A_CONST, "const", 0, 0, 1);
 390   add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
 391   add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
 392   add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1);
 393   add_attribute (A_MODE, "mode", 1, 1, 1);
 394   add_attribute (A_SECTION, "section", 1, 1, 1);
 395   add_attribute (A_ALIGNED, "aligned", 0, 1, 0);
 396   add_attribute (A_FORMAT, "format", 3, 3, 1);
 397   add_attribute (A_FORMAT_ARG, "format_arg", 1, 1, 1);
 398   add_attribute (A_WEAK, "weak", 0, 0, 1);
 399   add_attribute (A_ALIAS, "alias", 1, 1, 1);
 400   add_attribute (A_INIT_PRIORITY, "init_priority", 0, 1, 0);
 401   add_attribute (A_NO_INSTRUMENT_FUNCTION, "no_instrument_function", 0, 0, 1);
 402   add_attribute (A_NO_CHECK_MEMORY_USAGE, "no_check_memory_usage", 0, 0, 1);
 403 }
 404 \f
 405 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
 406    and install them in NODE, which is either a DECL (including a TYPE_DECL)
 407    or a TYPE.  PREFIX_ATTRIBUTES can appear after the declaration specifiers
 408    and declaration modifiers but before the declaration proper.  */
 409
 410 void
 411 decl_attributes (node, attributes, prefix_attributes)
 412      tree node, attributes, prefix_attributes;
 413 {
 414   tree decl = 0, type = 0;
 415   int is_type = 0;
 416   tree a;
 417
 418   if (attrtab_idx == 0)
 419     init_attributes ();
 420
 421   if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd')
 422     {
 423       decl = node;
 424       type = TREE_TYPE (decl);
 425       is_type = TREE_CODE (node) == TYPE_DECL;
 426     }
 427   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't')
 428     type = node, is_type = 1;
 429
 430 #ifdef PRAGMA_INSERT_ATTRIBUTES
 431   /* If the code in c-pragma.c wants to insert some attributes then
 432      allow it to do so.  Do this before allowing machine back ends to
 433      insert attributes, so that they have the opportunity to override
 434      anything done here.  */
 435   PRAGMA_INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
 436 #endif
 437
 438 #ifdef INSERT_ATTRIBUTES
 439   INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
 440 #endif
 441
 442   attributes = chainon (prefix_attributes, attributes);
 443
 444   for (a = attributes; a; a = TREE_CHAIN (a))
 445     {
 446       tree name = TREE_PURPOSE (a);
 447       tree args = TREE_VALUE (a);
 448       int i;
 449       enum attrs id;
 450
 451       for (i = 0; i < attrtab_idx; i++)
 452         if (attrtab[i].name == name)
 453           break;
 454
 455       if (i == attrtab_idx)
 456         {
 457           if (! valid_machine_attribute (name, args, decl, type))
 458             warning ("`%s' attribute directive ignored",
 459                      IDENTIFIER_POINTER (name));
 460           else if (decl != 0)
 461             type = TREE_TYPE (decl);
 462           continue;
 463         }
 464       else if (attrtab[i].decl_req && decl == 0)
 465         {
 466           warning ("`%s' attribute does not apply to types",
 467                    IDENTIFIER_POINTER (name));
 468           continue;
 469         }
 470       else if (list_length (args) < attrtab[i].min
 471                || list_length (args) > attrtab[i].max)
 472         {
 473           error ("wrong number of arguments specified for `%s' attribute",
 474                  IDENTIFIER_POINTER (name));
 475           continue;
 476         }
 477
 478       id = attrtab[i].id;
 479       switch (id)
 480         {
 481         case A_PACKED:
 482           if (is_type)
 483             TYPE_PACKED (type) = 1;
 484           else if (TREE_CODE (decl) == FIELD_DECL)
 485             DECL_PACKED (decl) = 1;
 486           /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 487              used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
 488           else
 489             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 490           break;
 491
 492         case A_NOCOMMON:
 493           if (TREE_CODE (decl) == VAR_DECL)
 494             DECL_COMMON (decl) = 0;
 495           else
 496             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 497           break;
 498
 499         case A_COMMON:
 500           if (TREE_CODE (decl) == VAR_DECL)
 501             DECL_COMMON (decl) = 1;
 502           else
 503             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 504           break;
 505
 506         case A_NORETURN:
 507           if (TREE_CODE (decl) == FUNCTION_DECL)
 508             TREE_THIS_VOLATILE (decl) = 1;
 509           else if (TREE_CODE (type) == POINTER_TYPE
 510                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 511             TREE_TYPE (decl) = type
 512               = build_pointer_type
 513                 (build_type_variant (TREE_TYPE (type),
 514                                      TREE_READONLY (TREE_TYPE (type)), 1));
 515           else
 516             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 517           break;
 518
 519         case A_UNUSED:
 520           if (is_type)
 521             TREE_USED (type) = 1;
 522           else if (TREE_CODE (decl) == PARM_DECL
 523                    || TREE_CODE (decl) == VAR_DECL
 524                    || TREE_CODE (decl) == FUNCTION_DECL
 525                    || TREE_CODE (decl) == LABEL_DECL)
 526             TREE_USED (decl) = 1;
 527           else
 528             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 529           break;
 530
 531         case A_CONST:
 532           if (TREE_CODE (decl) == FUNCTION_DECL)
 533             TREE_READONLY (decl) = 1;
 534           else if (TREE_CODE (type) == POINTER_TYPE
 535                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 536             TREE_TYPE (decl) = type
 537               = build_pointer_type
 538                 (build_type_variant (TREE_TYPE (type), 1,
 539                                      TREE_THIS_VOLATILE (TREE_TYPE (type))));
 540           else
 541             warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name));
 542           break;
 543
 544         case A_T_UNION:
 545           if (is_type
 546               && TREE_CODE (type) == UNION_TYPE
 547               && (decl == 0
 548                   || (TYPE_FIELDS (type) != 0
 549                       && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))))
 550             TYPE_TRANSPARENT_UNION (type) = 1;
 551           else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
 552                    && TREE_CODE (type) == UNION_TYPE
 553                    && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
 554             DECL_TRANSPARENT_UNION (decl) = 1;
 555           else
 556             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 557           break;
 558
 559         case A_CONSTRUCTOR:
 560           if (TREE_CODE (decl) == FUNCTION_DECL
 561               && TREE_CODE (type) == FUNCTION_TYPE
 562               && decl_function_context (decl) == 0)
 563             {
 564               DECL_STATIC_CONSTRUCTOR (decl) = 1;
 565               TREE_USED (decl) = 1;
 566             }
 567           else
 568             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 569           break;
 570
 571         case A_DESTRUCTOR:
 572           if (TREE_CODE (decl) == FUNCTION_DECL
 573               && TREE_CODE (type) == FUNCTION_TYPE
 574               && decl_function_context (decl) == 0)
 575             {
 576               DECL_STATIC_DESTRUCTOR (decl) = 1;
 577               TREE_USED (decl) = 1;
 578             }
 579           else
 580             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 581           break;
 582
 583         case A_MODE:
 584           if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
 585             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 586           else
 587             {
 588               int j;
 589               char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
 590               int len = strlen (p);
 591               enum machine_mode mode = VOIDmode;
 592               tree typefm;
 593
 594               if (len > 4 && p[0] == '_' && p[1] == '_'
 595                   && p[len - 1] == '_' && p[len - 2] == '_')
 596                 {
 597                   char *newp = (char *) alloca (len - 1);
 598
 599                   strcpy (newp, &p[2]);
 600                   newp[len - 4] = '\0';
 601                   p = newp;
 602                 }
 603
 604               /* Give this decl a type with the specified mode.
 605                  First check for the special modes.  */
 606               if (! strcmp (p, "byte"))
 607                 mode = byte_mode;
 608               else if (!strcmp (p, "word"))
 609                 mode = word_mode;
 610               else if (! strcmp (p, "pointer"))
 611                 mode = ptr_mode;
 612               else
 613                 for (j = 0; j < NUM_MACHINE_MODES; j++)
 614                   if (!strcmp (p, GET_MODE_NAME (j)))
 615                     mode = (enum machine_mode) j;
 616
 617               if (mode == VOIDmode)
 618                 error ("unknown machine mode `%s'", p);
 619               else if (0 == (typefm = type_for_mode (mode,
 620                                                      TREE_UNSIGNED (type))))
 621                 error ("no data type for mode `%s'", p);
 622               else
 623                 {
 624                   TREE_TYPE (decl) = type = typefm;
 625                   DECL_SIZE (decl) = 0;
 626                   layout_decl (decl, 0);
 627                 }
 628             }
 629           break;
 630
 631         case A_SECTION:
 632 #ifdef ASM_OUTPUT_SECTION_NAME
 633           if ((TREE_CODE (decl) == FUNCTION_DECL
 634                || TREE_CODE (decl) == VAR_DECL)
 635               && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 636             {
 637               if (TREE_CODE (decl) == VAR_DECL
 638                   && current_function_decl != NULL_TREE
 639                   && ! TREE_STATIC (decl))
 640                 error_with_decl (decl,
 641                   "section attribute cannot be specified for local variables");
 642               /* The decl may have already been given a section attribute from
 643                  a previous declaration.  Ensure they match.  */
 644               else if (DECL_SECTION_NAME (decl) != NULL_TREE
 645                        && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 646                                   TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 647                 error_with_decl (node,
 648                                  "section of `%s' conflicts with previous declaration");
 649               else
 650                 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 651             }
 652           else
 653             error_with_decl (node,
 654                            "section attribute not allowed for `%s'");
 655 #else
 656           error_with_decl (node,
 657                   "section attributes are not supported for this target");
 658 #endif
 659           break;
 660
 661         case A_ALIGNED:
 662           {
 663             tree align_expr
 664               = (args ? TREE_VALUE (args)
 665                  : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 666             int align;
 667
 668             /* Strip any NOPs of any kind.  */
 669             while (TREE_CODE (align_expr) == NOP_EXPR
 670                    || TREE_CODE (align_expr) == CONVERT_EXPR
 671                    || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
 672               align_expr = TREE_OPERAND (align_expr, 0);
 673
 674             if (TREE_CODE (align_expr) != INTEGER_CST)
 675               {
 676                 error ("requested alignment is not a constant");
 677                 continue;
 678               }
 679
 680             align = TREE_INT_CST_LOW (align_expr) * BITS_PER_UNIT;
 681
 682             if (exact_log2 (align) == -1)
 683               error ("requested alignment is not a power of 2");
 684             else if (is_type)
 685               TYPE_ALIGN (type) = align;
 686             else if (TREE_CODE (decl) != VAR_DECL
 687                      && TREE_CODE (decl) != FIELD_DECL)
 688               error_with_decl (decl,
 689                                "alignment may not be specified for `%s'");
 690             else
 691               DECL_ALIGN (decl) = align;
 692           }
 693           break;
 694
 695         case A_FORMAT:
 696           {
 697             tree format_type_id = TREE_VALUE (args);
 698             tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
 699             tree first_arg_num_expr
 700               = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
 701             int format_num;
 702             int first_arg_num;
 703             enum format_type format_type;
 704             tree argument;
 705             int arg_num;
 706
 707             if (TREE_CODE (decl) != FUNCTION_DECL)
 708               {
 709                 error_with_decl (decl,
 710                          "argument format specified for non-function `%s'");
 711                 continue;
 712               }
 713
 714             if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
 715               {
 716                 error ("unrecognized format specifier");
 717                 continue;
 718               }
 719             else
 720               {
 721                 char *p = IDENTIFIER_POINTER (format_type_id);
 722
 723                 if (!strcmp (p, "printf") || !strcmp (p, "__printf__"))
 724                   format_type = printf_format_type;
 725                 else if (!strcmp (p, "scanf") || !strcmp (p, "__scanf__"))
 726                   format_type = scanf_format_type;
 727                 else if (!strcmp (p, "strftime")
 728                          || !strcmp (p, "__strftime__"))
 729                   format_type = strftime_format_type;
 730                 else
 731                   {
 732                     error ("`%s' is an unrecognized format function type", p);
 733                     continue;
 734                   }
 735               }
 736
 737             /* Strip any conversions from the string index and first arg number
 738                and verify they are constants.  */
 739             while (TREE_CODE (format_num_expr) == NOP_EXPR
 740                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
 741                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 742               format_num_expr = TREE_OPERAND (format_num_expr, 0);
 743
 744             while (TREE_CODE (first_arg_num_expr) == NOP_EXPR
 745                    || TREE_CODE (first_arg_num_expr) == CONVERT_EXPR
 746                    || TREE_CODE (first_arg_num_expr) == NON_LVALUE_EXPR)
 747               first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0);
 748
 749             if (TREE_CODE (format_num_expr) != INTEGER_CST
 750                 || TREE_CODE (first_arg_num_expr) != INTEGER_CST)
 751               {
 752                 error ("format string has non-constant operand number");
 753                 continue;
 754               }
 755
 756             format_num = TREE_INT_CST_LOW (format_num_expr);
 757             first_arg_num = TREE_INT_CST_LOW (first_arg_num_expr);
 758             if (first_arg_num != 0 && first_arg_num <= format_num)
 759               {
 760                 error ("format string arg follows the args to be formatted");
 761                 continue;
 762               }
 763
 764             /* If a parameter list is specified, verify that the format_num
 765                argument is actually a string, in case the format attribute
 766                is in error.  */
 767             argument = TYPE_ARG_TYPES (type);
 768             if (argument)
 769               {
 770                 for (arg_num = 1; ; ++arg_num)
 771                   {
 772                     if (argument == 0 || arg_num == format_num)
 773                       break;
 774                     argument = TREE_CHAIN (argument);
 775                   }
 776                 if (! argument
 777                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 778                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 779                       != char_type_node))
 780                   {
 781                     error ("format string arg not a string type");
 782                     continue;
 783                   }
 784                 if (first_arg_num != 0)
 785                   {
 786                     /* Verify that first_arg_num points to the last arg,
 787                        the ...  */
 788                     while (argument)
 789                       arg_num++, argument = TREE_CHAIN (argument);
 790                   if (arg_num != first_arg_num)
 791                     {
 792                       error ("args to be formatted is not ...");
 793                       continue;
 794                     }
 795                   }
 796               }
 797
 798             record_function_format (DECL_NAME (decl),
 799                                     DECL_ASSEMBLER_NAME (decl),
 800                                     format_type, format_num, first_arg_num);
 801             break;
 802           }
 803
 804         case A_FORMAT_ARG:
 805           {
 806             tree format_num_expr = TREE_VALUE (args);
 807             int format_num, arg_num;
 808             tree argument;
 809
 810             if (TREE_CODE (decl) != FUNCTION_DECL)
 811               {
 812                 error_with_decl (decl,
 813                          "argument format specified for non-function `%s'");
 814                 continue;
 815               }
 816
 817             /* Strip any conversions from the first arg number and verify it
 818                is a constant.  */
 819             while (TREE_CODE (format_num_expr) == NOP_EXPR
 820                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
 821                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 822               format_num_expr = TREE_OPERAND (format_num_expr, 0);
 823
 824             if (TREE_CODE (format_num_expr) != INTEGER_CST)
 825               {
 826                 error ("format string has non-constant operand number");
 827                 continue;
 828               }
 829
 830             format_num = TREE_INT_CST_LOW (format_num_expr);
 831
 832             /* If a parameter list is specified, verify that the format_num
 833                argument is actually a string, in case the format attribute
 834                is in error.  */
 835             argument = TYPE_ARG_TYPES (type);
 836             if (argument)
 837               {
 838                 for (arg_num = 1; ; ++arg_num)
 839                   {
 840                     if (argument == 0 || arg_num == format_num)
 841                       break;
 842                     argument = TREE_CHAIN (argument);
 843                   }
 844                 if (! argument
 845                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 846                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 847                       != char_type_node))
 848                   {
 849                     error ("format string arg not a string type");
 850                     continue;
 851                   }
 852               }
 853
 854             if (TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) != POINTER_TYPE
 855                 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_TYPE (decl))))
 856                     != char_type_node))
 857               {
 858                 error ("function does not return string type");
 859                 continue;
 860               }
 861
 862             record_international_format (DECL_NAME (decl),
 863                                          DECL_ASSEMBLER_NAME (decl),
 864                                          format_num);
 865             break;
 866           }
 867
 868         case A_WEAK:
 869           declare_weak (decl);
 870           break;
 871
 872         case A_ALIAS:
 873           if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
 874               || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
 875             error_with_decl (decl,
 876                              "`%s' defined both normally and as an alias");
 877           else if (decl_function_context (decl) == 0)
 878             {
 879               tree id;
 880
 881               id = TREE_VALUE (args);
 882               if (TREE_CODE (id) != STRING_CST)
 883                 {
 884                   error ("alias arg not a string");
 885                   break;
 886                 }
 887               id = get_identifier (TREE_STRING_POINTER (id));
 888
 889               if (TREE_CODE (decl) == FUNCTION_DECL)
 890                 DECL_INITIAL (decl) = error_mark_node;
 891               else
 892                 DECL_EXTERNAL (decl) = 0;
 893               assemble_alias (decl, id);
 894             }
 895           else
 896             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 897           break;
 898
 899         case A_NO_CHECK_MEMORY_USAGE:
 900           if (TREE_CODE (decl) != FUNCTION_DECL)
 901             {
 902               error_with_decl (decl,
 903                                "`%s' attribute applies only to functions",
 904                                IDENTIFIER_POINTER (name));
 905             }
 906           else if (DECL_INITIAL (decl))
 907             {
 908               error_with_decl (decl,
 909                                "can't set `%s' attribute after definition",
 910                                IDENTIFIER_POINTER (name));
 911             }
 912           else
 913             DECL_NO_CHECK_MEMORY_USAGE (decl) = 1;
 914           break;
 915
 916         case A_INIT_PRIORITY:
 917           {
 918             tree initp_expr = (args ? TREE_VALUE (args): NULL_TREE);
 919             int pri;
 920
 921             if (initp_expr)
 922               STRIP_NOPS (initp_expr);
 923
 924             if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
 925               {
 926                 error ("requested init_priority is not an integer constant");
 927                 continue;
 928               }
 929
 930             pri = TREE_INT_CST_LOW (initp_expr);
 931
 932             if (is_type || TREE_CODE (decl) != VAR_DECL
 933                 || ! TREE_STATIC (decl)
 934                 || DECL_EXTERNAL (decl)
 935                 || (TREE_CODE (TREE_TYPE (decl)) != RECORD_TYPE
 936                     && TREE_CODE (TREE_TYPE (decl)) != UNION_TYPE)
 937                 /* Static objects in functions are initialized the
 938                    first time control passes through that
 939                    function. This is not precise enough to pin down an
 940                    init_priority value, so don't allow it. */
 941                 || current_function_decl)
 942               {
 943                 error ("can only use init_priority attribute on file-scope definitions of objects of class type");
 944                 continue;
 945               }
 946
 947             /* Check for init_priorities that are reserved for
 948                implementation. Reserved for language and runtime
 949                support implementations.*/
 950             if ((10 <= pri && pri <= 99)
 951                 /* Reserved for standard library implementations. */
 952                 || (500 <= pri && pri <= 999)
 953                 /* Reserved for objects with no attributes. */
 954                 || pri > (MAX_INIT_PRIORITY - 50))
 955               {
 956                 warning
 957                   ("requested init_priority is reserved for internal use");
 958                 continue;
 959               }
 960
 961             if (pri > MAX_INIT_PRIORITY || pri <= 0)
 962               {
 963                 error ("requested init_priority is out of range");
 964                 continue;
 965               }
 966
 967             static_aggregates_initp
 968               = perm_tree_cons (initp_expr, decl, static_aggregates_initp);
 969             break;
 970           }
 971
 972         case A_NO_INSTRUMENT_FUNCTION:
 973           if (TREE_CODE (decl) != FUNCTION_DECL)
 974             {
 975               error_with_decl (decl,
 976                                "`%s' attribute applies only to functions",
 977                                IDENTIFIER_POINTER (name));
 978             }
 979           else if (DECL_INITIAL (decl))
 980             {
 981               error_with_decl (decl,
 982                                "can't set `%s' attribute after definition",
 983                                IDENTIFIER_POINTER (name));
 984             }
 985           else
 986             DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
 987           break;
 988         }
 989     }
 990 }
 991
 992 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
 993    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
 994
 995    The head of the declspec list is stored in DECLSPECS.
 996    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
 997
 998    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
 999    the list elements.  We drop the containing TREE_LIST nodes and link the
1000    resulting attributes together the way decl_attributes expects them.  */
1001
1002 void
1003 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
1004      tree specs_attrs;
1005      tree *declspecs, *prefix_attributes;
1006 {
1007   tree t, s, a, next, specs, attrs;
1008
1009   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
1010   if (specs_attrs != NULL_TREE
1011       && TREE_CODE (specs_attrs) != TREE_LIST)
1012     {
1013       *declspecs = specs_attrs;
1014       *prefix_attributes = NULL_TREE;
1015       return;
1016     }
1017
1018   /* Remember to keep the lists in the same order, element-wise.  */
1019
1020   specs = s = NULL_TREE;
1021   attrs = a = NULL_TREE;
1022   for (t = specs_attrs; t; t = next)
1023     {
1024       next = TREE_CHAIN (t);
1025       /* Declspecs have a non-NULL TREE_VALUE.  */
1026       if (TREE_VALUE (t) != NULL_TREE)
1027         {
1028           if (specs == NULL_TREE)
1029             specs = s = t;
1030           else
1031             {
1032               TREE_CHAIN (s) = t;
1033               s = t;
1034             }
1035         }
1036       else
1037         {
1038           if (attrs == NULL_TREE)
1039             attrs = a = TREE_PURPOSE (t);
1040           else
1041             {
1042               TREE_CHAIN (a) = TREE_PURPOSE (t);
1043               a = TREE_PURPOSE (t);
1044             }
1045           /* More attrs can be linked here, move A to the end.  */
1046           while (TREE_CHAIN (a) != NULL_TREE)
1047             a = TREE_CHAIN (a);
1048         }
1049     }
1050
1051   /* Terminate the lists.  */
1052   if (s != NULL_TREE)
1053     TREE_CHAIN (s) = NULL_TREE;
1054   if (a != NULL_TREE)
1055     TREE_CHAIN (a) = NULL_TREE;
1056
1057   /* All done.  */
1058   *declspecs = specs;
1059   *prefix_attributes = attrs;
1060 }
1061
1062 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1063    This function is used by the parser when a rule will accept attributes
1064    in a particular position, but we don't want to support that just yet.
1065
1066    A warning is issued for every ignored attribute.  */
1067
1068 tree
1069 strip_attrs (specs_attrs)
1070      tree specs_attrs;
1071 {
1072   tree specs, attrs;
1073
1074   split_specs_attrs (specs_attrs, &specs, &attrs);
1075
1076   while (attrs)
1077     {
1078       warning ("`%s' attribute ignored",
1079                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
1080       attrs = TREE_CHAIN (attrs);
1081     }
1082
1083   return specs;
1084 }
1085 \f
1086 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
1087    a parameter list.  */
1088
1089 #define T_I     &integer_type_node
1090 #define T_L     &long_integer_type_node
1091 #define T_LL    &long_long_integer_type_node
1092 #define T_S     &short_integer_type_node
1093 #define T_UI    &unsigned_type_node
1094 #define T_UL    &long_unsigned_type_node
1095 #define T_ULL   &long_long_unsigned_type_node
1096 #define T_US    &short_unsigned_type_node
1097 #define T_F     &float_type_node
1098 #define T_D     &double_type_node
1099 #define T_LD    &long_double_type_node
1100 #define T_C     &char_type_node
1101 #define T_UC    &unsigned_char_type_node
1102 #define T_V     &void_type_node
1103 #define T_W     &wchar_type_node
1104 #define T_ST    &sizetype
1105
1106 typedef struct {
1107   char *format_chars;
1108   int pointer_count;
1109   /* Type of argument if no length modifier is used.  */
1110   tree *nolen;
1111   /* Type of argument if length modifier for shortening to byte is used.
1112      If NULL, then this modifier is not allowed.  */
1113   tree *hhlen;
1114   /* Type of argument if length modifier for shortening is used.
1115      If NULL, then this modifier is not allowed.  */
1116   tree *hlen;
1117   /* Type of argument if length modifier `l' is used.
1118      If NULL, then this modifier is not allowed.  */
1119   tree *llen;
1120   /* Type of argument if length modifier `q' or `ll' is used.
1121      If NULL, then this modifier is not allowed.  */
1122   tree *qlen;
1123   /* Type of argument if length modifier `L' is used.
1124      If NULL, then this modifier is not allowed.  */
1125   tree *bigllen;
1126   /* Type of argument if length modifier `Z' is used.
1127      If NULL, then this modifier is not allowed.  */
1128   tree *zlen;
1129   /* List of other modifier characters allowed with these options.  */
1130   char *flag_chars;
1131 } format_char_info;
1132
1133 static format_char_info print_char_table[] = {
1134   { "di",       0,      T_I,    T_I,    T_I,    T_L,    T_LL,   T_LL,   T_ST,   "-wp0 +"        },
1135   { "oxX",      0,      T_UI,   T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  T_ST,   "-wp0#"         },
1136   { "u",        0,      T_UI,   T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  T_ST,   "-wp0"          },
1137 /* A GNU extension.  */
1138   { "m",        0,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-wp"           },
1139   { "feEgGaA",  0,      T_D,    NULL,   NULL,   NULL,   NULL,   T_LD,   NULL,   "-wp0 +#"       },
1140   { "c",        0,      T_I,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "-w"            },
1141   { "C",        0,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-w"            },
1142   { "s",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "-wp"           },
1143   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-wp"           },
1144   { "p",        1,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-w"            },
1145   { "n",        1,      T_I,    NULL,   T_S,    T_L,    T_LL,   NULL,   NULL,   ""              },
1146   { NULL,       0,      NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL            }
1147 };
1148
1149 static format_char_info scan_char_table[] = {
1150   { "di",       1,      T_I,    T_C,    T_S,    T_L,    T_LL,   T_LL,   NULL,   "*"     },
1151   { "ouxX",     1,      T_UI,   T_UC,   T_US,   T_UL,   T_ULL,  T_ULL,  NULL,   "*"     },
1152   { "efgEGaA",  1,      T_F,    NULL,   NULL,   T_D,    NULL,   T_LD,   NULL,   "*"     },
1153   { "c",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "*"     },
1154   { "s",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "*a"    },
1155   { "[",        1,      T_C,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*a"    },
1156   { "C",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*"     },
1157   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*a"    },
1158   { "p",        2,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*"     },
1159   { "n",        1,      T_I,    T_C,    T_S,    T_L,    T_LL,   NULL,   NULL,   ""      },
1160   { NULL,       0,      NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL    }
1161 };
1162
1163 /* Handle format characters recognized by glibc's strftime.c.
1164    '2' - MUST do years as only two digits
1165    '3' - MAY do years as only two digits (depending on locale)
1166    'E' - E modifier is acceptable
1167    'O' - O modifier is acceptable to Standard C
1168    'o' - O modifier is acceptable as a GNU extension
1169    'G' - other GNU extensions  */
1170
1171 static format_char_info time_char_table[] = {
1172   { "y",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2EO-_0w" },
1173   { "D",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2" },
1174   { "g",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2O-_0w" },
1175   { "cx",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "3E" },
1176   { "%RTXnrt",          0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "" },
1177   { "P",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "G" },
1178   { "HIMSUWdemw",       0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Ow" },
1179   { "Vju",              0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Oow" },
1180   { "Gklsz",            0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0OGw" },
1181   { "ABZa",             0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "^#" },
1182   { "p",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "#" },
1183   { "bh",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "^" },
1184   { "CY",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0EOw" },
1185   { NULL,               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
1186 };
1187
1188 typedef struct function_format_info
1189 {
1190   struct function_format_info *next;  /* next structure on the list */
1191   tree name;                    /* identifier such as "printf" */
1192   tree assembler_name;          /* optional mangled identifier (for C++) */
1193   enum format_type format_type; /* type of format (printf, scanf, etc.) */
1194   int format_num;               /* number of format argument */
1195   int first_arg_num;            /* number of first arg (zero for varargs) */
1196 } function_format_info;
1197
1198 static function_format_info *function_format_list = NULL;
1199
1200 typedef struct international_format_info
1201 {
1202   struct international_format_info *next;  /* next structure on the list */
1203   tree name;                    /* identifier such as "gettext" */
1204   tree assembler_name;          /* optional mangled identifier (for C++) */
1205   int format_num;               /* number of format argument */
1206 } international_format_info;
1207
1208 static international_format_info *international_format_list = NULL;
1209
1210 static void check_format_info           PROTO((function_format_info *, tree));
1211
1212 /* Initialize the table of functions to perform format checking on.
1213    The ANSI functions are always checked (whether <stdio.h> is
1214    included or not), since it is common to call printf without
1215    including <stdio.h>.  There shouldn't be a problem with this,
1216    since ANSI reserves these function names whether you include the
1217    header file or not.  In any case, the checking is harmless.
1218
1219    Also initialize the name of function that modify the format string for
1220    internationalization purposes.  */
1221
1222 void
1223 init_function_format_info ()
1224 {
1225   record_function_format (get_identifier ("printf"), NULL_TREE,
1226                           printf_format_type, 1, 2);
1227   record_function_format (get_identifier ("fprintf"), NULL_TREE,
1228                           printf_format_type, 2, 3);
1229   record_function_format (get_identifier ("sprintf"), NULL_TREE,
1230                           printf_format_type, 2, 3);
1231   record_function_format (get_identifier ("scanf"), NULL_TREE,
1232                           scanf_format_type, 1, 2);
1233   record_function_format (get_identifier ("fscanf"), NULL_TREE,
1234                           scanf_format_type, 2, 3);
1235   record_function_format (get_identifier ("sscanf"), NULL_TREE,
1236                           scanf_format_type, 2, 3);
1237   record_function_format (get_identifier ("vprintf"), NULL_TREE,
1238                           printf_format_type, 1, 0);
1239   record_function_format (get_identifier ("vfprintf"), NULL_TREE,
1240                           printf_format_type, 2, 0);
1241   record_function_format (get_identifier ("vsprintf"), NULL_TREE,
1242                           printf_format_type, 2, 0);
1243   record_function_format (get_identifier ("strftime"), NULL_TREE,
1244                           strftime_format_type, 3, 0);
1245
1246   record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
1247   record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
1248   record_international_format (get_identifier ("dcgettext"), NULL_TREE, 2);
1249 }
1250
1251 /* Record information for argument format checking.  FUNCTION_IDENT is
1252    the identifier node for the name of the function to check (its decl
1253    need not exist yet).
1254    FORMAT_TYPE specifies the type of format checking.  FORMAT_NUM is the number
1255    of the argument which is the format control string (starting from 1).
1256    FIRST_ARG_NUM is the number of the first actual argument to check
1257    against the format string, or zero if no checking is not be done
1258    (e.g. for varargs such as vfprintf).  */
1259
1260 static void
1261 record_function_format (name, assembler_name, format_type,
1262                         format_num, first_arg_num)
1263       tree name;
1264       tree assembler_name;
1265       enum format_type format_type;
1266       int format_num;
1267       int first_arg_num;
1268 {
1269   function_format_info *info;
1270
1271   /* Re-use existing structure if it's there.  */
1272
1273   for (info = function_format_list; info; info = info->next)
1274     {
1275       if (info->name == name && info->assembler_name == assembler_name)
1276         break;
1277     }
1278   if (! info)
1279     {
1280       info = (function_format_info *) xmalloc (sizeof (function_format_info));
1281       info->next = function_format_list;
1282       function_format_list = info;
1283
1284       info->name = name;
1285       info->assembler_name = assembler_name;
1286     }
1287
1288   info->format_type = format_type;
1289   info->format_num = format_num;
1290   info->first_arg_num = first_arg_num;
1291 }
1292
1293 /* Record information for the names of function that modify the format
1294    argument to format functions.  FUNCTION_IDENT is the identifier node for
1295    the name of the function (its decl need not exist yet) and FORMAT_NUM is
1296    the number of the argument which is the format control string (starting
1297    from 1).  */
1298
1299 static void
1300 record_international_format (name, assembler_name, format_num)
1301       tree name;
1302       tree assembler_name;
1303       int format_num;
1304 {
1305   international_format_info *info;
1306
1307   /* Re-use existing structure if it's there.  */
1308
1309   for (info = international_format_list; info; info = info->next)
1310     {
1311       if (info->name == name && info->assembler_name == assembler_name)
1312         break;
1313     }
1314
1315   if (! info)
1316     {
1317       info
1318         = (international_format_info *)
1319           xmalloc (sizeof (international_format_info));
1320       info->next = international_format_list;
1321       international_format_list = info;
1322
1323       info->name = name;
1324       info->assembler_name = assembler_name;
1325     }
1326
1327   info->format_num = format_num;
1328 }
1329
1330 static char     tfaff[] = "too few arguments for format";
1331 \f
1332 /* Check the argument list of a call to printf, scanf, etc.
1333    NAME is the function identifier.
1334    ASSEMBLER_NAME is the function's assembler identifier.
1335    (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1336    PARAMS is the list of argument values.  */
1337
1338 void
1339 check_function_format (name, assembler_name, params)
1340      tree name;
1341      tree assembler_name;
1342      tree params;
1343 {
1344   function_format_info *info;
1345
1346   /* See if this function is a format function.  */
1347   for (info = function_format_list; info; info = info->next)
1348     {
1349       if (info->assembler_name
1350           ? (info->assembler_name == assembler_name)
1351           : (info->name == name))
1352         {
1353           /* Yup; check it.  */
1354           check_format_info (info, params);
1355           break;
1356         }
1357     }
1358 }
1359
1360 /* Check the argument list of a call to printf, scanf, etc.
1361    INFO points to the function_format_info structure.
1362    PARAMS is the list of argument values.  */
1363
1364 static void
1365 check_format_info (info, params)
1366      function_format_info *info;
1367      tree params;
1368 {
1369   int i;
1370   int arg_num;
1371   int suppressed, wide, precise;
1372   int length_char = 0;
1373   int format_char;
1374   int format_length;
1375   tree format_tree;
1376   tree cur_param;
1377   tree cur_type;
1378   tree wanted_type;
1379   tree first_fillin_param;
1380   char *format_chars;
1381   format_char_info *fci = NULL;
1382   char flag_chars[8];
1383   int has_operand_number = 0;
1384
1385   /* Skip to format argument.  If the argument isn't available, there's
1386      no work for us to do; prototype checking will catch the problem.  */
1387   for (arg_num = 1; ; ++arg_num)
1388     {
1389       if (params == 0)
1390         return;
1391       if (arg_num == info->format_num)
1392         break;
1393       params = TREE_CHAIN (params);
1394     }
1395   format_tree = TREE_VALUE (params);
1396   params = TREE_CHAIN (params);
1397   if (format_tree == 0)
1398     return;
1399
1400   /* We can only check the format if it's a string constant.  */
1401   while (TREE_CODE (format_tree) == NOP_EXPR)
1402     format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */
1403
1404   if (TREE_CODE (format_tree) == CALL_EXPR
1405       && TREE_CODE (TREE_OPERAND (format_tree, 0)) == ADDR_EXPR
1406       && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0))
1407           == FUNCTION_DECL))
1408     {
1409       tree function = TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0);
1410
1411       /* See if this is a call to a known internationalization function
1412          that modifies the format arg.  */
1413       international_format_info *info;
1414
1415       for (info = international_format_list; info; info = info->next)
1416         if (info->assembler_name
1417             ? (info->assembler_name == DECL_ASSEMBLER_NAME (function))
1418             : (info->name == DECL_NAME (function)))
1419           {
1420             tree inner_args;
1421             int i;
1422
1423             for (inner_args = TREE_OPERAND (format_tree, 1), i = 1;
1424                  inner_args != 0;
1425                  inner_args = TREE_CHAIN (inner_args), i++)
1426               if (i == info->format_num)
1427                 {
1428                   format_tree = TREE_VALUE (inner_args);
1429
1430                   while (TREE_CODE (format_tree) == NOP_EXPR)
1431                     format_tree = TREE_OPERAND (format_tree, 0);
1432                 }
1433           }
1434     }
1435
1436   if (integer_zerop (format_tree))
1437     {
1438       warning ("null format string");
1439       return;
1440     }
1441   if (TREE_CODE (format_tree) != ADDR_EXPR)
1442     return;
1443   format_tree = TREE_OPERAND (format_tree, 0);
1444   if (TREE_CODE (format_tree) != STRING_CST)
1445     return;
1446   format_chars = TREE_STRING_POINTER (format_tree);
1447   format_length = TREE_STRING_LENGTH (format_tree);
1448   if (format_length <= 1)
1449     warning ("zero-length format string");
1450   if (format_chars[--format_length] != 0)
1451     {
1452       warning ("unterminated format string");
1453       return;
1454     }
1455   /* Skip to first argument to check.  */
1456   while (arg_num + 1 < info->first_arg_num)
1457     {
1458       if (params == 0)
1459         return;
1460       params = TREE_CHAIN (params);
1461       ++arg_num;
1462     }
1463
1464   first_fillin_param = params;
1465   while (1)
1466     {
1467       int aflag;
1468       if (*format_chars == 0)
1469         {
1470           if (format_chars - TREE_STRING_POINTER (format_tree) != format_length)
1471             warning ("embedded `\\0' in format");
1472           if (info->first_arg_num != 0 && params != 0 && ! has_operand_number)
1473             warning ("too many arguments for format");
1474           return;
1475         }
1476       if (*format_chars++ != '%')
1477         continue;
1478       if (*format_chars == 0)
1479         {
1480           warning ("spurious trailing `%%' in format");
1481           continue;
1482         }
1483       if (*format_chars == '%')
1484         {
1485           ++format_chars;
1486           continue;
1487         }
1488       flag_chars[0] = 0;
1489       suppressed = wide = precise = FALSE;
1490       if (info->format_type == scanf_format_type)
1491         {
1492           suppressed = *format_chars == '*';
1493           if (suppressed)
1494             ++format_chars;
1495           while (ISDIGIT (*format_chars))
1496             ++format_chars;
1497         }
1498       else if (info->format_type == strftime_format_type)
1499         {
1500           while (*format_chars != 0 && index ("_-0^#", *format_chars) != 0)
1501             {
1502               if (pedantic)
1503                 warning ("ANSI C does not support the strftime `%c' flag",
1504                          *format_chars);
1505               if (index (flag_chars, *format_chars) != 0)
1506                 {
1507                   warning ("repeated `%c' flag in format",
1508                            *format_chars);
1509                   ++format_chars;
1510                 }
1511               else
1512                 {
1513                   i = strlen (flag_chars);
1514                   flag_chars[i++] = *format_chars++;
1515                   flag_chars[i] = 0;
1516                 }
1517             }
1518           while (ISDIGIT ((unsigned char) *format_chars))
1519             {
1520               wide = TRUE;
1521               ++format_chars;
1522             }
1523           if (wide && pedantic)
1524             warning ("ANSI C does not support strftime format width");
1525           if (*format_chars == 'E' || *format_chars == 'O')
1526             {
1527               i = strlen (flag_chars);
1528               flag_chars[i++] = *format_chars++;
1529               flag_chars[i] = 0;
1530               if (*format_chars == 'E' || *format_chars == 'O')
1531                 {
1532                   warning ("multiple E/O modifiers in format");
1533                   while (*format_chars == 'E' || *format_chars == 'O')
1534                     ++format_chars;
1535                 }
1536             }
1537         }
1538       else if (info->format_type == printf_format_type)
1539         {
1540           /* See if we have a number followed by a dollar sign.  If we do,
1541              it is an operand number, so set PARAMS to that operand.  */
1542           if (*format_chars >= '0' && *format_chars <= '9')
1543             {
1544               char *p = format_chars;
1545
1546               while (*p >= '0' && *p++ <= '9')
1547                 ;
1548
1549               if (*p == '$')
1550                 {
1551                   int opnum = atoi (format_chars);
1552
1553                   params = first_fillin_param;
1554                   format_chars = p + 1;
1555                   has_operand_number = 1;
1556
1557                   for (i = 1; i < opnum && params != 0; i++)
1558                     params = TREE_CHAIN (params);
1559
1560                   if (opnum == 0 || params == 0)
1561                     {
1562                       warning ("operand number out of range in format");
1563                       return;
1564                     }
1565                 }
1566             }
1567
1568           while (*format_chars != 0 && index (" +#0-", *format_chars) != 0)
1569             {
1570               if (index (flag_chars, *format_chars) != 0)
1571                 warning ("repeated `%c' flag in format", *format_chars++);
1572               else
1573                 {
1574                   i = strlen (flag_chars);
1575                   flag_chars[i++] = *format_chars++;
1576                   flag_chars[i] = 0;
1577                 }
1578             }
1579           /* "If the space and + flags both appear,
1580              the space flag will be ignored."  */
1581           if (index (flag_chars, ' ') != 0
1582               && index (flag_chars, '+') != 0)
1583             warning ("use of both ` ' and `+' flags in format");
1584           /* "If the 0 and - flags both appear,
1585              the 0 flag will be ignored."  */
1586           if (index (flag_chars, '0') != 0
1587               && index (flag_chars, '-') != 0)
1588             warning ("use of both `0' and `-' flags in format");
1589           if (*format_chars == '*')
1590             {
1591               wide = TRUE;
1592               /* "...a field width...may be indicated by an asterisk.
1593                  In this case, an int argument supplies the field width..."  */
1594               ++format_chars;
1595               if (params == 0)
1596                 {
1597                   warning (tfaff);
1598                   return;
1599                 }
1600               if (info->first_arg_num != 0)
1601                 {
1602                   cur_param = TREE_VALUE (params);
1603                   params = TREE_CHAIN (params);
1604                   ++arg_num;
1605                   /* size_t is generally not valid here.
1606                      It will work on most machines, because size_t and int
1607                      have the same mode.  But might as well warn anyway,
1608                      since it will fail on other machines.  */
1609                   if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1610                        != integer_type_node)
1611                       &&
1612                       (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1613                        != unsigned_type_node))
1614                     warning ("field width is not type int (arg %d)", arg_num);
1615                 }
1616             }
1617           else
1618             {
1619               while (ISDIGIT (*format_chars))
1620                 {
1621                   wide = TRUE;
1622                   ++format_chars;
1623                 }
1624             }
1625           if (*format_chars == '.')
1626             {
1627               precise = TRUE;
1628               ++format_chars;
1629               if (*format_chars != '*' && !ISDIGIT (*format_chars))
1630                 warning ("`.' not followed by `*' or digit in format");
1631               /* "...a...precision...may be indicated by an asterisk.
1632                  In this case, an int argument supplies the...precision."  */
1633               if (*format_chars == '*')
1634                 {
1635                   if (info->first_arg_num != 0)
1636                     {
1637                       ++format_chars;
1638                       if (params == 0)
1639                         {
1640                           warning (tfaff);
1641                           return;
1642                         }
1643                       cur_param = TREE_VALUE (params);
1644                       params = TREE_CHAIN (params);
1645                       ++arg_num;
1646                       if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1647                           != integer_type_node)
1648                         warning ("field width is not type int (arg %d)",
1649                                  arg_num);
1650                     }
1651                 }
1652               else
1653                 {
1654                   while (ISDIGIT (*format_chars))
1655                     ++format_chars;
1656                 }
1657             }
1658         }
1659
1660       aflag = 0;
1661
1662       if (info->format_type != strftime_format_type)
1663         {
1664           if (*format_chars == 'h' || *format_chars == 'l')
1665             length_char = *format_chars++;
1666           else if (*format_chars == 'q' || *format_chars == 'L')
1667             {
1668               length_char = *format_chars++;
1669               if (pedantic)
1670                 warning ("ANSI C does not support the `%c' length modifier",
1671                          length_char);
1672             }
1673           else if (*format_chars == 'Z')
1674             {
1675               length_char = *format_chars++;
1676               if (pedantic)
1677                 warning ("ANSI C does not support the `Z' length modifier");
1678             }
1679           else
1680             length_char = 0;
1681           if (length_char == 'l' && *format_chars == 'l')
1682             {
1683               length_char = 'q', format_chars++;
1684               /* FIXME: Is allowed in ISO C 9x.  */
1685               if (pedantic)
1686                 warning ("ANSI C does not support the `ll' length modifier");
1687             }
1688           else if (length_char == 'h' && *format_chars == 'h')
1689             {
1690               length_char = 'H', format_chars++;
1691               /* FIXME: Is allowed in ISO C 9x.  */
1692               if (pedantic)
1693                 warning ("ANSI C does not support the `hh' length modifier");
1694             }
1695           if (*format_chars == 'a' && info->format_type == scanf_format_type)
1696             {
1697               if (format_chars[1] == 's' || format_chars[1] == 'S'
1698                   || format_chars[1] == '[')
1699                 {
1700                   /* `a' is used as a flag.  */
1701                   aflag = 1;
1702                   format_chars++;
1703                 }
1704             }
1705           if (suppressed && length_char != 0)
1706             warning ("use of `*' and `%c' together in format", length_char);
1707         }
1708       format_char = *format_chars;
1709       if (format_char == 0
1710           || (info->format_type != strftime_format_type && format_char == '%'))
1711         {
1712           warning ("conversion lacks type at end of format");
1713           continue;
1714         }
1715       /* The m, C, and S formats are GNU extensions.  */
1716       if (pedantic && info->format_type != strftime_format_type
1717           && (format_char == 'm' || format_char == 'C' || format_char == 'S'))
1718         warning ("ANSI C does not support the `%c' format", format_char);
1719       /* ??? The a and A formats are C9X extensions, and should be allowed
1720          when a C9X option is added.  */
1721       if (pedantic && info->format_type != strftime_format_type
1722           && (format_char == 'a' || format_char == 'A'))
1723         warning ("ANSI C does not support the `%c' format", format_char);
1724       format_chars++;
1725       switch (info->format_type)
1726         {
1727         case printf_format_type:
1728           fci = print_char_table;
1729           break;
1730         case scanf_format_type:
1731           fci = scan_char_table;
1732           break;
1733         case strftime_format_type:
1734           fci = time_char_table;
1735           break;
1736         default:
1737           abort ();
1738         }
1739       while (fci->format_chars != 0
1740              && index (fci->format_chars, format_char) == 0)
1741           ++fci;
1742       if (fci->format_chars == 0)
1743         {
1744           if (format_char >= 040 && format_char < 0177)
1745             warning ("unknown conversion type character `%c' in format",
1746                      format_char);
1747           else
1748             warning ("unknown conversion type character 0x%x in format",
1749                      format_char);
1750           continue;
1751         }
1752       if (pedantic)
1753         {
1754           if (index (fci->flag_chars, 'G') != 0)
1755             warning ("ANSI C does not support `%%%c'", format_char);
1756           if (index (fci->flag_chars, 'o') != 0
1757               && index (flag_chars, 'O') != 0)
1758             warning ("ANSI C does not support `%%O%c'", format_char);
1759         }
1760       if (wide && index (fci->flag_chars, 'w') == 0)
1761         warning ("width used with `%c' format", format_char);
1762       if (index (fci->flag_chars, '2') != 0)
1763         warning ("`%%%c' yields only last 2 digits of year", format_char);
1764       else if (index (fci->flag_chars, '3') != 0)
1765         warning ("`%%%c' yields only last 2 digits of year in some locales",
1766                  format_char);
1767       if (precise && index (fci->flag_chars, 'p') == 0)
1768         warning ("precision used with `%c' format", format_char);
1769       if (aflag && index (fci->flag_chars, 'a') == 0)
1770         {
1771           warning ("`a' flag used with `%c' format", format_char);
1772           /* To simplify the following code.  */
1773           aflag = 0;
1774         }
1775       /* The a flag is a GNU extension.  */
1776       else if (pedantic && aflag)
1777         warning ("ANSI C does not support the `a' flag");
1778       if (info->format_type == scanf_format_type && format_char == '[')
1779         {
1780           /* Skip over scan set, in case it happens to have '%' in it.  */
1781           if (*format_chars == '^')
1782             ++format_chars;
1783           /* Find closing bracket; if one is hit immediately, then
1784              it's part of the scan set rather than a terminator.  */
1785           if (*format_chars == ']')
1786             ++format_chars;
1787           while (*format_chars && *format_chars != ']')
1788             ++format_chars;
1789           if (*format_chars != ']')
1790             /* The end of the format string was reached.  */
1791             warning ("no closing `]' for `%%[' format");
1792         }
1793       if (suppressed)
1794         {
1795           if (index (fci->flag_chars, '*') == 0)
1796             warning ("suppression of `%c' conversion in format", format_char);
1797           continue;
1798         }
1799       for (i = 0; flag_chars[i] != 0; ++i)
1800         {
1801           if (index (fci->flag_chars, flag_chars[i]) == 0)
1802             warning ("flag `%c' used with type `%c'",
1803                      flag_chars[i], format_char);
1804         }
1805       if (info->format_type == strftime_format_type)
1806         continue;
1807       if (precise && index (flag_chars, '0') != 0
1808           && (format_char == 'd' || format_char == 'i'
1809               || format_char == 'o' || format_char == 'u'
1810               || format_char == 'x' || format_char == 'X'))
1811         warning ("`0' flag ignored with precision specifier and `%c' format",
1812                  format_char);
1813       switch (length_char)
1814         {
1815         default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break;
1816         case 'H': wanted_type = fci->hhlen ? *(fci->hhlen) : 0; break;
1817         case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break;
1818         case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break;
1819         case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break;
1820         case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
1821         case 'Z': wanted_type = fci->zlen ? *fci->zlen : 0; break;
1822         }
1823       if (wanted_type == 0)
1824         warning ("use of `%c' length character with `%c' type character",
1825                  length_char, format_char);
1826
1827       /* Finally. . .check type of argument against desired type!  */
1828       if (info->first_arg_num == 0)
1829         continue;
1830       if (fci->pointer_count == 0 && wanted_type == void_type_node)
1831         /* This specifier takes no argument.  */
1832         continue;
1833       if (params == 0)
1834         {
1835           warning (tfaff);
1836           return;
1837         }
1838       cur_param = TREE_VALUE (params);
1839       params = TREE_CHAIN (params);
1840       ++arg_num;
1841       cur_type = TREE_TYPE (cur_param);
1842
1843       STRIP_NOPS (cur_param);
1844
1845       /* Check the types of any additional pointer arguments
1846          that precede the "real" argument.  */
1847       for (i = 0; i < fci->pointer_count + aflag; ++i)
1848         {
1849           if (TREE_CODE (cur_type) == POINTER_TYPE)
1850             {
1851               cur_type = TREE_TYPE (cur_type);
1852
1853               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
1854                 cur_param = TREE_OPERAND (cur_param, 0);
1855               else
1856                 cur_param = 0;
1857
1858               continue;
1859             }
1860           if (TREE_CODE (cur_type) != ERROR_MARK)
1861             warning ("format argument is not a %s (arg %d)",
1862                      ((fci->pointer_count + aflag == 1)
1863                       ? "pointer" : "pointer to a pointer"),
1864                      arg_num);
1865           break;
1866         }
1867
1868       /* See if this is an attempt to write into a const type with
1869          scanf or with printf "%n".  */
1870       if ((info->format_type == scanf_format_type
1871            || (info->format_type == printf_format_type
1872                && format_char == 'n'))
1873           && i == fci->pointer_count + aflag
1874           && wanted_type != 0
1875           && TREE_CODE (cur_type) != ERROR_MARK
1876           && (TYPE_READONLY (cur_type)
1877               || (cur_param != 0
1878                   && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
1879                       || (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'd'
1880                           && TREE_READONLY (cur_param))))))
1881         warning ("writing into constant object (arg %d)", arg_num);
1882
1883       /* Check the type of the "real" argument, if there's a type we want.  */
1884       if (i == fci->pointer_count + aflag && wanted_type != 0
1885           && TREE_CODE (cur_type) != ERROR_MARK
1886           && wanted_type != TYPE_MAIN_VARIANT (cur_type)
1887           /* If we want `void *', allow any pointer type.
1888              (Anything else would already have got a warning.)  */
1889           && ! (wanted_type == void_type_node
1890                 && fci->pointer_count > 0)
1891           /* Don't warn about differences merely in signedness.  */
1892           && !(TREE_CODE (wanted_type) == INTEGER_TYPE
1893                && TREE_CODE (TYPE_MAIN_VARIANT (cur_type)) == INTEGER_TYPE
1894                && (TREE_UNSIGNED (wanted_type)
1895                    ? wanted_type == (cur_type = unsigned_type (cur_type))
1896                    : wanted_type == (cur_type = signed_type (cur_type))))
1897           /* Likewise, "signed char", "unsigned char" and "char" are
1898              equivalent but the above test won't consider them equivalent.  */
1899           && ! (wanted_type == char_type_node
1900                 && (TYPE_MAIN_VARIANT (cur_type) == signed_char_type_node
1901                     || TYPE_MAIN_VARIANT (cur_type) == unsigned_char_type_node)))
1902         {
1903           register char *this;
1904           register char *that;
1905
1906           this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
1907           that = 0;
1908           if (TREE_CODE (cur_type) != ERROR_MARK
1909               && TYPE_NAME (cur_type) != 0
1910               && TREE_CODE (cur_type) != INTEGER_TYPE
1911               && !(TREE_CODE (cur_type) == POINTER_TYPE
1912                    && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE))
1913             {
1914               if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL
1915                   && DECL_NAME (TYPE_NAME (cur_type)) != 0)
1916                 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
1917               else
1918                 that = IDENTIFIER_POINTER (TYPE_NAME (cur_type));
1919             }
1920
1921           /* A nameless type can't possibly match what the format wants.
1922              So there will be a warning for it.
1923              Make up a string to describe vaguely what it is.  */
1924           if (that == 0)
1925             {
1926               if (TREE_CODE (cur_type) == POINTER_TYPE)
1927                 that = "pointer";
1928               else
1929                 that = "different type";
1930             }
1931
1932           /* Make the warning better in case of mismatch of int vs long.  */
1933           if (TREE_CODE (cur_type) == INTEGER_TYPE
1934               && TREE_CODE (wanted_type) == INTEGER_TYPE
1935               && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type)
1936               && TYPE_NAME (cur_type) != 0
1937               && TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL)
1938             that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
1939
1940           if (strcmp (this, that) != 0)
1941             warning ("%s format, %s arg (arg %d)", this, that, arg_num);
1942         }
1943     }
1944 }
1945 \f
1946 /* Print a warning if a constant expression had overflow in folding.
1947    Invoke this function on every expression that the language
1948    requires to be a constant expression.
1949    Note the ANSI C standard says it is erroneous for a
1950    constant expression to overflow.  */
1951
1952 void
1953 constant_expression_warning (value)
1954      tree value;
1955 {
1956   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1957        || TREE_CODE (value) == COMPLEX_CST)
1958       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1959     pedwarn ("overflow in constant expression");
1960 }
1961
1962 /* Print a warning if an expression had overflow in folding.
1963    Invoke this function on every expression that
1964    (1) appears in the source code, and
1965    (2) might be a constant expression that overflowed, and
1966    (3) is not already checked by convert_and_check;
1967    however, do not invoke this function on operands of explicit casts.  */
1968
1969 void
1970 overflow_warning (value)
1971      tree value;
1972 {
1973   if ((TREE_CODE (value) == INTEGER_CST
1974        || (TREE_CODE (value) == COMPLEX_CST
1975            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1976       && TREE_OVERFLOW (value))
1977     {
1978       TREE_OVERFLOW (value) = 0;
1979       if (skip_evaluation == 0)
1980         warning ("integer overflow in expression");
1981     }
1982   else if ((TREE_CODE (value) == REAL_CST
1983             || (TREE_CODE (value) == COMPLEX_CST
1984                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1985            && TREE_OVERFLOW (value))
1986     {
1987       TREE_OVERFLOW (value) = 0;
1988       if (skip_evaluation == 0)
1989         warning ("floating point overflow in expression");
1990     }
1991 }
1992
1993 /* Print a warning if a large constant is truncated to unsigned,
1994    or if -Wconversion is used and a constant < 0 is converted to unsigned.
1995    Invoke this function on every expression that might be implicitly
1996    converted to an unsigned type.  */
1997
1998 void
1999 unsigned_conversion_warning (result, operand)
2000      tree result, operand;
2001 {
2002   if (TREE_CODE (operand) == INTEGER_CST
2003       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
2004       && TREE_UNSIGNED (TREE_TYPE (result))
2005       && skip_evaluation == 0
2006       && !int_fits_type_p (operand, TREE_TYPE (result)))
2007     {
2008       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
2009         /* This detects cases like converting -129 or 256 to unsigned char.  */
2010         warning ("large integer implicitly truncated to unsigned type");
2011       else if (warn_conversion)
2012         warning ("negative integer implicitly converted to unsigned type");
2013     }
2014 }
2015
2016 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2017    Invoke this function on every expression that is converted implicitly,
2018    i.e. because of language rules and not because of an explicit cast.  */
2019
2020 tree
2021 convert_and_check (type, expr)
2022      tree type, expr;
2023 {
2024   tree t = convert (type, expr);
2025   if (TREE_CODE (t) == INTEGER_CST)
2026     {
2027       if (TREE_OVERFLOW (t))
2028         {
2029           TREE_OVERFLOW (t) = 0;
2030
2031           /* Do not diagnose overflow in a constant expression merely
2032              because a conversion overflowed.  */
2033           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
2034
2035           /* No warning for converting 0x80000000 to int.  */
2036           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
2037                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
2038                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
2039             /* If EXPR fits in the unsigned version of TYPE,
2040                don't warn unless pedantic.  */
2041             if ((pedantic
2042                  || TREE_UNSIGNED (type)
2043                  || ! int_fits_type_p (expr, unsigned_type (type)))
2044                 && skip_evaluation == 0)
2045               warning ("overflow in implicit constant conversion");
2046         }
2047       else
2048         unsigned_conversion_warning (t, expr);
2049     }
2050   return t;
2051 }
2052 \f
2053 void
2054 c_expand_expr_stmt (expr)
2055      tree expr;
2056 {
2057   /* Do default conversion if safe and possibly important,
2058      in case within ({...}).  */
2059   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
2060       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
2061     expr = default_conversion (expr);
2062
2063   if (TREE_TYPE (expr) != error_mark_node
2064       && TYPE_SIZE (TREE_TYPE (expr)) == 0
2065       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
2066     error ("expression statement has incomplete type");
2067
2068   expand_expr_stmt (expr);
2069 }
2070 \f
2071 /* Validate the expression after `case' and apply default promotions.  */
2072
2073 tree
2074 check_case_value (value)
2075      tree value;
2076 {
2077   if (value == NULL_TREE)
2078     return value;
2079
2080   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
2081   STRIP_TYPE_NOPS (value);
2082
2083   if (TREE_CODE (value) != INTEGER_CST
2084       && value != error_mark_node)
2085     {
2086       error ("case label does not reduce to an integer constant");
2087       value = error_mark_node;
2088     }
2089   else
2090     /* Promote char or short to int.  */
2091     value = default_conversion (value);
2092
2093   constant_expression_warning (value);
2094
2095   return value;
2096 }
2097 \f
2098 /* Return an integer type with BITS bits of precision,
2099    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2100
2101 tree
2102 type_for_size (bits, unsignedp)
2103      unsigned bits;
2104      int unsignedp;
2105 {
2106   if (bits == TYPE_PRECISION (integer_type_node))
2107     return unsignedp ? unsigned_type_node : integer_type_node;
2108
2109   if (bits == TYPE_PRECISION (signed_char_type_node))
2110     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2111
2112   if (bits == TYPE_PRECISION (short_integer_type_node))
2113     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2114
2115   if (bits == TYPE_PRECISION (long_integer_type_node))
2116     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2117
2118   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2119     return (unsignedp ? long_long_unsigned_type_node
2120             : long_long_integer_type_node);
2121
2122   if (bits <= TYPE_PRECISION (intQI_type_node))
2123     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2124
2125   if (bits <= TYPE_PRECISION (intHI_type_node))
2126     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2127
2128   if (bits <= TYPE_PRECISION (intSI_type_node))
2129     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2130
2131   if (bits <= TYPE_PRECISION (intDI_type_node))
2132     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2133
2134   return 0;
2135 }
2136
2137 /* Return a data type that has machine mode MODE.
2138    If the mode is an integer,
2139    then UNSIGNEDP selects between signed and unsigned types.  */
2140
2141 tree
2142 type_for_mode (mode, unsignedp)
2143      enum machine_mode mode;
2144      int unsignedp;
2145 {
2146   if (mode == TYPE_MODE (integer_type_node))
2147     return unsignedp ? unsigned_type_node : integer_type_node;
2148
2149   if (mode == TYPE_MODE (signed_char_type_node))
2150     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2151
2152   if (mode == TYPE_MODE (short_integer_type_node))
2153     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2154
2155   if (mode == TYPE_MODE (long_integer_type_node))
2156     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2157
2158   if (mode == TYPE_MODE (long_long_integer_type_node))
2159     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2160
2161   if (mode == TYPE_MODE (intQI_type_node))
2162     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2163
2164   if (mode == TYPE_MODE (intHI_type_node))
2165     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2166
2167   if (mode == TYPE_MODE (intSI_type_node))
2168     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2169
2170   if (mode == TYPE_MODE (intDI_type_node))
2171     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2172
2173 #if HOST_BITS_PER_WIDE_INT >= 64
2174   if (mode == TYPE_MODE (intTI_type_node))
2175     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2176 #endif
2177
2178   if (mode == TYPE_MODE (float_type_node))
2179     return float_type_node;
2180
2181   if (mode == TYPE_MODE (double_type_node))
2182     return double_type_node;
2183
2184   if (mode == TYPE_MODE (long_double_type_node))
2185     return long_double_type_node;
2186
2187   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2188     return build_pointer_type (char_type_node);
2189
2190   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2191     return build_pointer_type (integer_type_node);
2192
2193   return 0;
2194 }
2195 \f
2196 /* Return the minimum number of bits needed to represent VALUE in a
2197    signed or unsigned type, UNSIGNEDP says which.  */
2198
2199 int
2200 min_precision (value, unsignedp)
2201      tree value;
2202      int unsignedp;
2203 {
2204   int log;
2205
2206   /* If the value is negative, compute its negative minus 1.  The latter
2207      adjustment is because the absolute value of the largest negative value
2208      is one larger than the largest positive value.  This is equivalent to
2209      a bit-wise negation, so use that operation instead.  */
2210
2211   if (tree_int_cst_sgn (value) < 0)
2212     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2213
2214   /* Return the number of bits needed, taking into account the fact
2215      that we need one more bit for a signed than unsigned type.  */
2216
2217   if (integer_zerop (value))
2218     log = 0;
2219   else if (TREE_INT_CST_HIGH (value) != 0)
2220     log = HOST_BITS_PER_WIDE_INT + floor_log2 (TREE_INT_CST_HIGH (value));
2221   else
2222     log = floor_log2 (TREE_INT_CST_LOW (value));
2223
2224   return log + 1 + ! unsignedp;
2225 }
2226 \f
2227 /* Print an error message for invalid operands to arith operation CODE.
2228    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
2229
2230 void
2231 binary_op_error (code)
2232      enum tree_code code;
2233 {
2234   register char *opname;
2235
2236   switch (code)
2237     {
2238     case NOP_EXPR:
2239       error ("invalid truth-value expression");
2240       return;
2241
2242     case PLUS_EXPR:
2243       opname = "+"; break;
2244     case MINUS_EXPR:
2245       opname = "-"; break;
2246     case MULT_EXPR:
2247       opname = "*"; break;
2248     case MAX_EXPR:
2249       opname = "max"; break;
2250     case MIN_EXPR:
2251       opname = "min"; break;
2252     case EQ_EXPR:
2253       opname = "=="; break;
2254     case NE_EXPR:
2255       opname = "!="; break;
2256     case LE_EXPR:
2257       opname = "<="; break;
2258     case GE_EXPR:
2259       opname = ">="; break;
2260     case LT_EXPR:
2261       opname = "<"; break;
2262     case GT_EXPR:
2263       opname = ">"; break;
2264     case LSHIFT_EXPR:
2265       opname = "<<"; break;
2266     case RSHIFT_EXPR:
2267       opname = ">>"; break;
2268     case TRUNC_MOD_EXPR:
2269     case FLOOR_MOD_EXPR:
2270       opname = "%"; break;
2271     case TRUNC_DIV_EXPR:
2272     case FLOOR_DIV_EXPR:
2273       opname = "/"; break;
2274     case BIT_AND_EXPR:
2275       opname = "&"; break;
2276     case BIT_IOR_EXPR:
2277       opname = "|"; break;
2278     case TRUTH_ANDIF_EXPR:
2279       opname = "&&"; break;
2280     case TRUTH_ORIF_EXPR:
2281       opname = "||"; break;
2282     case BIT_XOR_EXPR:
2283       opname = "^"; break;
2284     case LROTATE_EXPR:
2285     case RROTATE_EXPR:
2286       opname = "rotate"; break;
2287     default:
2288       opname = "unknown"; break;
2289     }
2290   error ("invalid operands to binary %s", opname);
2291 }
2292 \f
2293 /* Subroutine of build_binary_op, used for comparison operations.
2294    See if the operands have both been converted from subword integer types
2295    and, if so, perhaps change them both back to their original type.
2296    This function is also responsible for converting the two operands
2297    to the proper common type for comparison.
2298
2299    The arguments of this function are all pointers to local variables
2300    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2301    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2302
2303    If this function returns nonzero, it means that the comparison has
2304    a constant value.  What this function returns is an expression for
2305    that value.  */
2306
2307 tree
2308 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2309      tree *op0_ptr, *op1_ptr;
2310      tree *restype_ptr;
2311      enum tree_code *rescode_ptr;
2312 {
2313   register tree type;
2314   tree op0 = *op0_ptr;
2315   tree op1 = *op1_ptr;
2316   int unsignedp0, unsignedp1;
2317   int real1, real2;
2318   tree primop0, primop1;
2319   enum tree_code code = *rescode_ptr;
2320
2321   /* Throw away any conversions to wider types
2322      already present in the operands.  */
2323
2324   primop0 = get_narrower (op0, &unsignedp0);
2325   primop1 = get_narrower (op1, &unsignedp1);
2326
2327   /* Handle the case that OP0 does not *contain* a conversion
2328      but it *requires* conversion to FINAL_TYPE.  */
2329
2330   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2331     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2332   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2333     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2334
2335   /* If one of the operands must be floated, we cannot optimize.  */
2336   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2337   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2338
2339   /* If first arg is constant, swap the args (changing operation
2340      so value is preserved), for canonicalization.  Don't do this if
2341      the second arg is 0.  */
2342
2343   if (TREE_CONSTANT (primop0)
2344       && ! integer_zerop (primop1) && ! real_zerop (primop1))
2345     {
2346       register tree tem = primop0;
2347       register int temi = unsignedp0;
2348       primop0 = primop1;
2349       primop1 = tem;
2350       tem = op0;
2351       op0 = op1;
2352       op1 = tem;
2353       *op0_ptr = op0;
2354       *op1_ptr = op1;
2355       unsignedp0 = unsignedp1;
2356       unsignedp1 = temi;
2357       temi = real1;
2358       real1 = real2;
2359       real2 = temi;
2360
2361       switch (code)
2362         {
2363         case LT_EXPR:
2364           code = GT_EXPR;
2365           break;
2366         case GT_EXPR:
2367           code = LT_EXPR;
2368           break;
2369         case LE_EXPR:
2370           code = GE_EXPR;
2371           break;
2372         case GE_EXPR:
2373           code = LE_EXPR;
2374           break;
2375         default:
2376           break;
2377         }
2378       *rescode_ptr = code;
2379     }
2380
2381   /* If comparing an integer against a constant more bits wide,
2382      maybe we can deduce a value of 1 or 0 independent of the data.
2383      Or else truncate the constant now
2384      rather than extend the variable at run time.
2385
2386      This is only interesting if the constant is the wider arg.
2387      Also, it is not safe if the constant is unsigned and the
2388      variable arg is signed, since in this case the variable
2389      would be sign-extended and then regarded as unsigned.
2390      Our technique fails in this case because the lowest/highest
2391      possible unsigned results don't follow naturally from the
2392      lowest/highest possible values of the variable operand.
2393      For just EQ_EXPR and NE_EXPR there is another technique that
2394      could be used: see if the constant can be faithfully represented
2395      in the other operand's type, by truncating it and reextending it
2396      and see if that preserves the constant's value.  */
2397
2398   if (!real1 && !real2
2399       && TREE_CODE (primop1) == INTEGER_CST
2400       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2401     {
2402       int min_gt, max_gt, min_lt, max_lt;
2403       tree maxval, minval;
2404       /* 1 if comparison is nominally unsigned.  */
2405       int unsignedp = TREE_UNSIGNED (*restype_ptr);
2406       tree val;
2407
2408       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
2409
2410       maxval = TYPE_MAX_VALUE (type);
2411       minval = TYPE_MIN_VALUE (type);
2412
2413       if (unsignedp && !unsignedp0)
2414         *restype_ptr = signed_type (*restype_ptr);
2415
2416       if (TREE_TYPE (primop1) != *restype_ptr)
2417         primop1 = convert (*restype_ptr, primop1);
2418       if (type != *restype_ptr)
2419         {
2420           minval = convert (*restype_ptr, minval);
2421           maxval = convert (*restype_ptr, maxval);
2422         }
2423
2424       if (unsignedp && unsignedp0)
2425         {
2426           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2427           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2428           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2429           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2430         }
2431       else
2432         {
2433           min_gt = INT_CST_LT (primop1, minval);
2434           max_gt = INT_CST_LT (primop1, maxval);
2435           min_lt = INT_CST_LT (minval, primop1);
2436           max_lt = INT_CST_LT (maxval, primop1);
2437         }
2438
2439       val = 0;
2440       /* This used to be a switch, but Genix compiler can't handle that.  */
2441       if (code == NE_EXPR)
2442         {
2443           if (max_lt || min_gt)
2444             val = boolean_true_node;
2445         }
2446       else if (code == EQ_EXPR)
2447         {
2448           if (max_lt || min_gt)
2449             val = boolean_false_node;
2450         }
2451       else if (code == LT_EXPR)
2452         {
2453           if (max_lt)
2454             val = boolean_true_node;
2455           if (!min_lt)
2456             val = boolean_false_node;
2457         }
2458       else if (code == GT_EXPR)
2459         {
2460           if (min_gt)
2461             val = boolean_true_node;
2462           if (!max_gt)
2463             val = boolean_false_node;
2464         }
2465       else if (code == LE_EXPR)
2466         {
2467           if (!max_gt)
2468             val = boolean_true_node;
2469           if (min_gt)
2470             val = boolean_false_node;
2471         }
2472       else if (code == GE_EXPR)
2473         {
2474           if (!min_lt)
2475             val = boolean_true_node;
2476           if (max_lt)
2477             val = boolean_false_node;
2478         }
2479
2480       /* If primop0 was sign-extended and unsigned comparison specd,
2481          we did a signed comparison above using the signed type bounds.
2482          But the comparison we output must be unsigned.
2483
2484          Also, for inequalities, VAL is no good; but if the signed
2485          comparison had *any* fixed result, it follows that the
2486          unsigned comparison just tests the sign in reverse
2487          (positive values are LE, negative ones GE).
2488          So we can generate an unsigned comparison
2489          against an extreme value of the signed type.  */
2490
2491       if (unsignedp && !unsignedp0)
2492         {
2493           if (val != 0)
2494             switch (code)
2495               {
2496               case LT_EXPR:
2497               case GE_EXPR:
2498                 primop1 = TYPE_MIN_VALUE (type);
2499                 val = 0;
2500                 break;
2501
2502               case LE_EXPR:
2503               case GT_EXPR:
2504                 primop1 = TYPE_MAX_VALUE (type);
2505                 val = 0;
2506                 break;
2507
2508               default:
2509                 break;
2510               }
2511           type = unsigned_type (type);
2512         }
2513
2514       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2515         {
2516           /* This is the case of (char)x >?< 0x80, which people used to use
2517              expecting old C compilers to change the 0x80 into -0x80.  */
2518           if (val == boolean_false_node)
2519             warning ("comparison is always false due to limited range of data type");
2520           if (val == boolean_true_node)
2521             warning ("comparison is always true due to limited range of data type");
2522         }
2523
2524       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2525         {
2526           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
2527           if (val == boolean_false_node)
2528             warning ("comparison is always false due to limited range of data type");
2529           if (val == boolean_true_node)
2530             warning ("comparison is always true due to limited range of data type");
2531         }
2532
2533       if (val != 0)
2534         {
2535           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2536           if (TREE_SIDE_EFFECTS (primop0))
2537             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2538           return val;
2539         }
2540
2541       /* Value is not predetermined, but do the comparison
2542          in the type of the operand that is not constant.
2543          TYPE is already properly set.  */
2544     }
2545   else if (real1 && real2
2546            && (TYPE_PRECISION (TREE_TYPE (primop0))
2547                == TYPE_PRECISION (TREE_TYPE (primop1))))
2548     type = TREE_TYPE (primop0);
2549
2550   /* If args' natural types are both narrower than nominal type
2551      and both extend in the same manner, compare them
2552      in the type of the wider arg.
2553      Otherwise must actually extend both to the nominal
2554      common type lest different ways of extending
2555      alter the result.
2556      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2557
2558   else if (unsignedp0 == unsignedp1 && real1 == real2
2559            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2560            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2561     {
2562       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2563       type = signed_or_unsigned_type (unsignedp0
2564                                       || TREE_UNSIGNED (*restype_ptr),
2565                                       type);
2566       /* Make sure shorter operand is extended the right way
2567          to match the longer operand.  */
2568       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
2569                          primop0);
2570       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
2571                          primop1);
2572     }
2573   else
2574     {
2575       /* Here we must do the comparison on the nominal type
2576          using the args exactly as we received them.  */
2577       type = *restype_ptr;
2578       primop0 = op0;
2579       primop1 = op1;
2580
2581       if (!real1 && !real2 && integer_zerop (primop1)
2582           && TREE_UNSIGNED (*restype_ptr))
2583         {
2584           tree value = 0;
2585           switch (code)
2586             {
2587             case GE_EXPR:
2588               /* All unsigned values are >= 0, so we warn if extra warnings
2589                  are requested.  However, if OP0 is a constant that is
2590                  >= 0, the signedness of the comparison isn't an issue,
2591                  so suppress the warning.  */
2592               if (extra_warnings
2593                   && ! (TREE_CODE (primop0) == INTEGER_CST
2594                         && ! TREE_OVERFLOW (convert (signed_type (type),
2595                                                      primop0))))
2596                 warning ("comparison of unsigned expression >= 0 is always true");
2597               value = boolean_true_node;
2598               break;
2599
2600             case LT_EXPR:
2601               if (extra_warnings
2602                   && ! (TREE_CODE (primop0) == INTEGER_CST
2603                         && ! TREE_OVERFLOW (convert (signed_type (type),
2604                                                      primop0))))
2605                 warning ("comparison of unsigned expression < 0 is always false");
2606               value = boolean_false_node;
2607               break;
2608
2609             default:
2610               break;
2611             }
2612
2613           if (value != 0)
2614             {
2615               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2616               if (TREE_SIDE_EFFECTS (primop0))
2617                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2618                               primop0, value);
2619               return value;
2620             }
2621         }
2622     }
2623
2624   *op0_ptr = convert (type, primop0);
2625   *op1_ptr = convert (type, primop1);
2626
2627   *restype_ptr = boolean_type_node;
2628
2629   return 0;
2630 }
2631 \f
2632 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2633    or validate its data type for an `if' or `while' statement or ?..: exp.
2634
2635    This preparation consists of taking the ordinary
2636    representation of an expression expr and producing a valid tree
2637    boolean expression describing whether expr is nonzero.  We could
2638    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2639    but we optimize comparisons, &&, ||, and !.
2640
2641    The resulting type should always be `boolean_type_node'.  */
2642
2643 tree
2644 truthvalue_conversion (expr)
2645      tree expr;
2646 {
2647   if (TREE_CODE (expr) == ERROR_MARK)
2648     return expr;
2649
2650 #if 0 /* This appears to be wrong for C++.  */
2651   /* These really should return error_mark_node after 2.4 is stable.
2652      But not all callers handle ERROR_MARK properly.  */
2653   switch (TREE_CODE (TREE_TYPE (expr)))
2654     {
2655     case RECORD_TYPE:
2656       error ("struct type value used where scalar is required");
2657       return boolean_false_node;
2658
2659     case UNION_TYPE:
2660       error ("union type value used where scalar is required");
2661       return boolean_false_node;
2662
2663     case ARRAY_TYPE:
2664       error ("array type value used where scalar is required");
2665       return boolean_false_node;
2666
2667     default:
2668       break;
2669     }
2670 #endif /* 0 */
2671
2672   switch (TREE_CODE (expr))
2673     {
2674       /* It is simpler and generates better code to have only TRUTH_*_EXPR
2675          or comparison expressions as truth values at this level.  */
2676 #if 0
2677     case COMPONENT_REF:
2678       /* A one-bit unsigned bit-field is already acceptable.  */
2679       if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
2680           && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
2681         return expr;
2682       break;
2683 #endif
2684
2685     case EQ_EXPR:
2686       /* It is simpler and generates better code to have only TRUTH_*_EXPR
2687          or comparison expressions as truth values at this level.  */
2688 #if 0
2689       if (integer_zerop (TREE_OPERAND (expr, 1)))
2690         return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
2691 #endif
2692     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2693     case TRUTH_ANDIF_EXPR:
2694     case TRUTH_ORIF_EXPR:
2695     case TRUTH_AND_EXPR:
2696     case TRUTH_OR_EXPR:
2697     case TRUTH_XOR_EXPR:
2698     case TRUTH_NOT_EXPR:
2699       TREE_TYPE (expr) = boolean_type_node;
2700       return expr;
2701
2702     case ERROR_MARK:
2703       return expr;
2704
2705     case INTEGER_CST:
2706       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2707
2708     case REAL_CST:
2709       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2710
2711     case ADDR_EXPR:
2712       /* If we are taking the address of a external decl, it might be zero
2713          if it is weak, so we cannot optimize.  */
2714       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (expr, 0))) == 'd'
2715           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2716         break;
2717
2718       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2719         return build (COMPOUND_EXPR, boolean_type_node,
2720                       TREE_OPERAND (expr, 0), boolean_true_node);
2721       else
2722         return boolean_true_node;
2723
2724     case COMPLEX_EXPR:
2725       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2726                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2727                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
2728                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
2729                               0);
2730
2731     case NEGATE_EXPR:
2732     case ABS_EXPR:
2733     case FLOAT_EXPR:
2734     case FFS_EXPR:
2735       /* These don't change whether an object is non-zero or zero.  */
2736       return truthvalue_conversion (TREE_OPERAND (expr, 0));
2737
2738     case LROTATE_EXPR:
2739     case RROTATE_EXPR:
2740       /* These don't change whether an object is zero or non-zero, but
2741          we can't ignore them if their second arg has side-effects.  */
2742       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2743         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2744                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
2745       else
2746         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2747
2748     case COND_EXPR:
2749       /* Distribute the conversion into the arms of a COND_EXPR.  */
2750       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2751                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
2752                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
2753
2754     case CONVERT_EXPR:
2755       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2756          since that affects how `default_conversion' will behave.  */
2757       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2758           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2759         break;
2760       /* fall through...  */
2761     case NOP_EXPR:
2762       /* If this is widening the argument, we can ignore it.  */
2763       if (TYPE_PRECISION (TREE_TYPE (expr))
2764           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2765         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2766       break;
2767
2768     case MINUS_EXPR:
2769       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2770          this case.  */
2771       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2772           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2773         break;
2774       /* fall through...  */
2775     case BIT_XOR_EXPR:
2776       /* This and MINUS_EXPR can be changed into a comparison of the
2777          two objects.  */
2778       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2779           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2780         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2781                                 TREE_OPERAND (expr, 1), 1);
2782       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2783                               fold (build1 (NOP_EXPR,
2784                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2785                                             TREE_OPERAND (expr, 1))), 1);
2786
2787     case BIT_AND_EXPR:
2788       if (integer_onep (TREE_OPERAND (expr, 1))
2789           && TREE_TYPE (expr) != boolean_type_node)
2790         /* Using convert here would cause infinite recursion.  */
2791         return build1 (NOP_EXPR, boolean_type_node, expr);
2792       break;
2793
2794     case MODIFY_EXPR:
2795       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2796         warning ("suggest parentheses around assignment used as truth value");
2797       break;
2798
2799     default:
2800       break;
2801     }
2802
2803   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2804     {
2805       tree tem = save_expr (expr);
2806       return (build_binary_op
2807               ((TREE_SIDE_EFFECTS (expr)
2808                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2809                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2810                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2811                0));
2812     }
2813
2814   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2815 }
2816 \f
2817 #if USE_CPPLIB
2818 /* Read the rest of a #-directive from input stream FINPUT.
2819    In normal use, the directive name and the white space after it
2820    have already been read, so they won't be included in the result.
2821    We allow for the fact that the directive line may contain
2822    a newline embedded within a character or string literal which forms
2823    a part of the directive.
2824
2825    The value is a string in a reusable buffer.  It remains valid
2826    only until the next time this function is called.  */
2827 unsigned char *yy_cur, *yy_lim;
2828
2829 #define GETC() (yy_cur < yy_lim ? *yy_cur++ : yy_get_token ())
2830 #define UNGETC(c) ((c), yy_cur--)
2831
2832 int
2833 yy_get_token ()
2834 {
2835   for (;;)
2836     {
2837       parse_in.limit = parse_in.token_buffer;
2838       cpp_token = cpp_get_token (&parse_in);
2839       if (cpp_token == CPP_EOF)
2840         return -1;
2841       yy_lim = CPP_PWRITTEN (&parse_in);
2842       yy_cur = parse_in.token_buffer;
2843       if (yy_cur < yy_lim)
2844         return *yy_cur++;
2845     }
2846 }
2847
2848 char *
2849 get_directive_line ()
2850 {
2851   static char *directive_buffer = NULL;
2852   static unsigned buffer_length = 0;
2853   register char *p;
2854   register char *buffer_limit;
2855   register int looking_for = 0;
2856   register int char_escaped = 0;
2857
2858   if (buffer_length == 0)
2859     {
2860       directive_buffer = (char *)xmalloc (128);
2861       buffer_length = 128;
2862     }
2863
2864   buffer_limit = &directive_buffer[buffer_length];
2865
2866   for (p = directive_buffer; ; )
2867     {
2868       int c;
2869
2870       /* Make buffer bigger if it is full.  */
2871       if (p >= buffer_limit)
2872         {
2873           register unsigned bytes_used = (p - directive_buffer);
2874
2875           buffer_length *= 2;
2876           directive_buffer
2877             = (char *)xrealloc (directive_buffer, buffer_length);
2878           p = &directive_buffer[bytes_used];
2879           buffer_limit = &directive_buffer[buffer_length];
2880         }
2881
2882       c = GETC ();
2883
2884       /* Discard initial whitespace.  */
2885       if ((c == ' ' || c == '\t') && p == directive_buffer)
2886         continue;
2887
2888       /* Detect the end of the directive.  */
2889       if (c == '\n' && looking_for == 0)
2890         {
2891           UNGETC (c);
2892           c = '\0';
2893         }
2894
2895       *p++ = c;
2896
2897       if (c == 0)
2898         return directive_buffer;
2899
2900       /* Handle string and character constant syntax.  */
2901       if (looking_for)
2902         {
2903           if (looking_for == c && !char_escaped)
2904             looking_for = 0;    /* Found terminator... stop looking.  */
2905         }
2906       else
2907         if (c == '\'' || c == '"')
2908           looking_for = c;      /* Don't stop buffering until we see another
2909                                    another one of these (or an EOF).  */
2910
2911       /* Handle backslash.  */
2912       char_escaped = (c == '\\' && ! char_escaped);
2913     }
2914 }
2915 #else
2916 /* Read the rest of a #-directive from input stream FINPUT.
2917    In normal use, the directive name and the white space after it
2918    have already been read, so they won't be included in the result.
2919    We allow for the fact that the directive line may contain
2920    a newline embedded within a character or string literal which forms
2921    a part of the directive.
2922
2923    The value is a string in a reusable buffer.  It remains valid
2924    only until the next time this function is called.
2925
2926    The terminating character ('\n' or EOF) is left in FINPUT for the
2927    caller to re-read.  */
2928
2929 char *
2930 get_directive_line (finput)
2931      register FILE *finput;
2932 {
2933   static char *directive_buffer = NULL;
2934   static unsigned buffer_length = 0;
2935   register char *p;
2936   register char *buffer_limit;
2937   register int looking_for = 0;
2938   register int char_escaped = 0;
2939
2940   if (buffer_length == 0)
2941     {
2942       directive_buffer = (char *)xmalloc (128);
2943       buffer_length = 128;
2944     }
2945
2946   buffer_limit = &directive_buffer[buffer_length];
2947
2948   for (p = directive_buffer; ; )
2949     {
2950       int c;
2951
2952       /* Make buffer bigger if it is full.  */
2953       if (p >= buffer_limit)
2954         {
2955           register unsigned bytes_used = (p - directive_buffer);
2956
2957           buffer_length *= 2;
2958           directive_buffer
2959             = (char *)xrealloc (directive_buffer, buffer_length);
2960           p = &directive_buffer[bytes_used];
2961           buffer_limit = &directive_buffer[buffer_length];
2962         }
2963
2964       c = getc (finput);
2965
2966       /* Discard initial whitespace.  */
2967       if ((c == ' ' || c == '\t') && p == directive_buffer)
2968         continue;
2969
2970       /* Detect the end of the directive.  */
2971       if (looking_for == 0
2972           && (c == '\n' || c == EOF))
2973         {
2974           ungetc (c, finput);
2975           c = '\0';
2976         }
2977
2978       *p++ = c;
2979
2980       if (c == 0)
2981         return directive_buffer;
2982
2983       /* Handle string and character constant syntax.  */
2984       if (looking_for)
2985         {
2986           if (looking_for == c && !char_escaped)
2987             looking_for = 0;    /* Found terminator... stop looking.  */
2988         }
2989       else
2990         if (c == '\'' || c == '"')
2991           looking_for = c;      /* Don't stop buffering until we see another
2992                                    one of these (or an EOF).  */
2993
2994       /* Handle backslash.  */
2995       char_escaped = (c == '\\' && ! char_escaped);
2996     }
2997 }
2998 #endif /* !USE_CPPLIB */
2999 \f
3000 /* Make a variant type in the proper way for C/C++, propagating qualifiers
3001    down to the element type of an array.  */
3002
3003 tree
3004 c_build_qualified_type (type, type_quals)
3005      tree type;
3006      int type_quals;
3007 {
3008   /* A restrict-qualified pointer type must be a pointer to object or
3009      incomplete type.  Note that the use of POINTER_TYPE_P also allows
3010      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
3011      the C++ front-end also use POINTER_TYPE for pointer-to-member
3012      values, so even though it should be illegal to use `restrict'
3013      with such an entity we don't flag that here.  Thus, special case
3014      code for that case is required in the C++ front-end.  */
3015   if ((type_quals & TYPE_QUAL_RESTRICT)
3016       && (!POINTER_TYPE_P (type)
3017           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
3018     {
3019       error ("invalid use of `restrict'");
3020       type_quals &= ~TYPE_QUAL_RESTRICT;
3021     }
3022
3023   if (TREE_CODE (type) == ARRAY_TYPE)
3024     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
3025                                                      type_quals),
3026                              TYPE_DOMAIN (type));
3027   return build_qualified_type (type, type_quals);
3028 }
3029
3030 /* Apply the TYPE_QUALS to the new DECL.  */
3031
3032 void
3033 c_apply_type_quals_to_decl (type_quals, decl)
3034      int type_quals;
3035      tree decl;
3036 {
3037   if (type_quals & TYPE_QUAL_CONST)
3038     TREE_READONLY (decl) = 1;
3039   if (type_quals & TYPE_QUAL_VOLATILE)
3040     {
3041       TREE_SIDE_EFFECTS (decl) = 1;
3042       TREE_THIS_VOLATILE (decl) = 1;
3043     }
3044   if (type_quals & TYPE_QUAL_RESTRICT)
3045     {
3046       if (!TREE_TYPE (decl)
3047           || !POINTER_TYPE_P (TREE_TYPE (decl))
3048           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
3049         error ("invalid use of `restrict'");
3050       else if (flag_strict_aliasing)
3051         {
3052           /* No two restricted pointers can point at the same thing.
3053              However, a restricted pointer can point at the same thing
3054              as an unrestricted pointer, if that unrestricted pointer
3055              is based on the restricted pointer.  So, we make the
3056              alias set for the restricted pointer a subset of the
3057              alias set for the type pointed to by the type of the
3058              decl.  */
3059
3060           int pointed_to_alias_set
3061             = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
3062
3063           if (!pointed_to_alias_set)
3064             /* It's not legal to make a subset of alias set zero.  */
3065             ;
3066           else
3067             {
3068               DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
3069               record_alias_subset  (pointed_to_alias_set,
3070                                     DECL_POINTER_ALIAS_SET (decl));
3071             }
3072         }
3073     }
3074 }
3075
3076 /* T is an expression with pointer type.  Find the DECL on which this
3077    expression is based.  (For example, in `a[i]' this would be `a'.)
3078    If there is no such DECL, or a unique decl cannot be determined,
3079    NULL_TREE is retured.  */
3080
3081 static tree
3082 c_find_base_decl (t)
3083      tree t;
3084 {
3085   int i;
3086   tree decl;
3087
3088   if (t == NULL_TREE || t == error_mark_node)
3089     return NULL_TREE;
3090
3091   if (!POINTER_TYPE_P (TREE_TYPE (t)))
3092     return NULL_TREE;
3093
3094   decl = NULL_TREE;
3095
3096   if (TREE_CODE (t) == FIELD_DECL
3097       || TREE_CODE (t) == PARM_DECL
3098       || TREE_CODE (t) == VAR_DECL)
3099     /* Aha, we found a pointer-typed declaration.  */
3100     return t;
3101
3102   /* It would be nice to deal with COMPONENT_REFs here.  If we could
3103      tell that `a' and `b' were the same, then `a->f' and `b->f' are
3104      also the same.  */
3105
3106   /* Handle general expressions.  */
3107   switch (TREE_CODE_CLASS (TREE_CODE (t)))
3108     {
3109     case '1':
3110     case '2':
3111     case '3':
3112       for (i = tree_code_length [(int) TREE_CODE (t)]; --i >= 0;)
3113         {
3114           tree d = c_find_base_decl (TREE_OPERAND (t, i));
3115           if (d)
3116             {
3117               if (!decl)
3118                 decl = d;
3119               else if (d && d != decl)
3120                 /* Two different declarations.  That's confusing; let's
3121                    just assume we don't know what's going on.  */
3122                 decl = NULL_TREE;
3123             }
3124         }
3125       break;
3126
3127     default:
3128       break;
3129     }
3130
3131   return decl;
3132 }
3133
3134 /* Return the typed-based alias set for T, which may be an expression
3135    or a type.  */
3136
3137 int
3138 c_get_alias_set (t)
3139      tree t;
3140 {
3141   tree type;
3142   tree u;
3143
3144   if (t == error_mark_node)
3145     return 0;
3146
3147   type = (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
3148     ? t : TREE_TYPE (t);
3149
3150   if (type == error_mark_node)
3151     return 0;
3152
3153   /* Deal with special cases first; for certain kinds of references
3154      we're interested in more than just the type.  */
3155
3156   if (TREE_CODE (t) == BIT_FIELD_REF)
3157     /* Perhaps reads and writes to this piece of data alias fields
3158        neighboring the bitfield.  Perhaps that's impossible.  For now,
3159        let's just assume that bitfields can alias everything, which is
3160        the conservative assumption.  */
3161     return 0;
3162
3163   /* Permit type-punning when accessing a union, provided the access
3164      is directly through the union.  For example, this code does not
3165      permit taking the address of a union member and then storing
3166      through it.  Even the type-punning allowed here is a GCC
3167      extension, albeit a common and useful one; the C standard says
3168      that such accesses have implementation-defined behavior.  */
3169   for (u = t;
3170        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3171        u = TREE_OPERAND (u, 0))
3172     if (TREE_CODE (u) == COMPONENT_REF
3173         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3174       return 0;
3175
3176   if (TREE_CODE (t) == INDIRECT_REF)
3177     {
3178       /* Check for accesses through restrict-qualified pointers.  */
3179       tree decl = c_find_base_decl (TREE_OPERAND (t, 0));
3180
3181       if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))
3182         /* We use the alias set indicated in the declaration.  */
3183         return DECL_POINTER_ALIAS_SET (decl);
3184     }
3185
3186   /* From here on, only the type matters.  */
3187
3188   if (TREE_CODE (t) == COMPONENT_REF
3189       && DECL_BIT_FIELD_TYPE (TREE_OPERAND (t, 1)))
3190     /* Since build_modify_expr calls get_unwidened for stores to
3191        component references, the type of a bit field can be changed
3192        from (say) `unsigned int : 16' to `unsigned short' or from
3193        `enum E : 16' to `short'.  We want the real type of the
3194        bit-field in this case, not some the integral equivalent.  */
3195     type = DECL_BIT_FIELD_TYPE (TREE_OPERAND (t, 1));
3196
3197   if (TYPE_ALIAS_SET_KNOWN_P (type))
3198     /* If we've already calculated the value, just return it.  */
3199     return TYPE_ALIAS_SET (type);
3200   else if (TYPE_MAIN_VARIANT (type) != type)
3201     /* The C standard specifically allows aliasing between
3202        cv-qualified variants of types.  */
3203     TYPE_ALIAS_SET (type) = c_get_alias_set (TYPE_MAIN_VARIANT (type));
3204   else if (TREE_CODE (type) == INTEGER_TYPE)
3205     {
3206       tree signed_variant;
3207
3208       /* The C standard specifically allows aliasing between signed and
3209          unsigned variants of the same type.  We treat the signed
3210          variant as canonical.  */
3211       signed_variant = signed_type (type);
3212
3213       if (signed_variant != type)
3214         TYPE_ALIAS_SET (type) = c_get_alias_set (signed_variant);
3215       else if (signed_variant == signed_char_type_node)
3216         /* The C standard guarantess that any object may be accessed
3217            via an lvalue that has character type.  We don't have to
3218            check for unsigned_char_type_node or char_type_node because
3219            we are specifically looking at the signed variant.  */
3220         TYPE_ALIAS_SET (type) = 0;
3221     }
3222   else if (TREE_CODE (type) == ARRAY_TYPE)
3223     /* Anything that can alias one of the array elements can alias
3224        the entire array as well.  */
3225     TYPE_ALIAS_SET (type) = c_get_alias_set (TREE_TYPE (type));
3226   else if (TREE_CODE (type) == FUNCTION_TYPE)
3227     /* There are no objects of FUNCTION_TYPE, so there's no point in
3228        using up an alias set for them.  (There are, of course,
3229        pointers and references to functions, but that's
3230        different.)  */
3231     TYPE_ALIAS_SET (type) = 0;
3232   else if (TREE_CODE (type) == RECORD_TYPE
3233            || TREE_CODE (type) == UNION_TYPE)
3234     /* If TYPE is a struct or union type then we're reading or
3235        writing an entire struct.  Thus, we don't know anything about
3236        aliasing.  (In theory, such an access can only alias objects
3237        whose type is the same as one of the fields, recursively, but
3238        we don't yet make any use of that information.)  */
3239     TYPE_ALIAS_SET (type) = 0;
3240
3241   if (!TYPE_ALIAS_SET_KNOWN_P (type))
3242     /* TYPE is something we haven't seen before.  Put it in a new
3243        alias set.  */
3244     TYPE_ALIAS_SET (type) = new_alias_set ();
3245
3246   return TYPE_ALIAS_SET (type);
3247 }