OSDN Git Service

* gimplify.c (gimplify_call_expr): Make return in memory explicit.
[pf3gnuchains/gcc-fork.git] / gcc / c-common.c
1 /* Subroutines shared by all languages that are variants of C.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "intl.h"
27 #include "tree.h"
28 #include "flags.h"
29 #include "output.h"
30 #include "c-pragma.h"
31 #include "rtl.h"
32 #include "ggc.h"
33 #include "varray.h"
34 #include "expr.h"
35 #include "c-common.h"
36 #include "diagnostic.h"
37 #include "tm_p.h"
38 #include "obstack.h"
39 #include "cpplib.h"
40 #include "target.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
43 #include "c-tree.h"
44 #include "toplev.h"
45 #include "tree-iterator.h"
46 #include "hashtab.h"
47 #include "tree-mudflap.h"
48 #include "opts.h"
49
50 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
51
52 /* We let tm.h override the types used here, to handle trivial differences
53    such as the choice of unsigned int or long unsigned int for size_t.
54    When machines start needing nontrivial differences in the size type,
55    it would be best to do something here to figure out automatically
56    from other information what type to use.  */
57
58 #ifndef SIZE_TYPE
59 #define SIZE_TYPE "long unsigned int"
60 #endif
61
62 #ifndef PID_TYPE
63 #define PID_TYPE "int"
64 #endif
65
66 #ifndef WCHAR_TYPE
67 #define WCHAR_TYPE "int"
68 #endif
69
70 /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
71 #define MODIFIED_WCHAR_TYPE \
72         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
73
74 #ifndef PTRDIFF_TYPE
75 #define PTRDIFF_TYPE "long int"
76 #endif
77
78 #ifndef WINT_TYPE
79 #define WINT_TYPE "unsigned int"
80 #endif
81
82 #ifndef INTMAX_TYPE
83 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
84                      ? "int"                                    \
85                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86                         ? "long int"                            \
87                         : "long long int"))
88 #endif
89
90 #ifndef UINTMAX_TYPE
91 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
92                      ? "unsigned int"                           \
93                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
94                         ? "long unsigned int"                   \
95                         : "long long unsigned int"))
96 #endif
97
98 /* The following symbols are subsumed in the c_global_trees array, and
99    listed here individually for documentation purposes.
100
101    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
102
103         tree short_integer_type_node;
104         tree long_integer_type_node;
105         tree long_long_integer_type_node;
106
107         tree short_unsigned_type_node;
108         tree long_unsigned_type_node;
109         tree long_long_unsigned_type_node;
110
111         tree truthvalue_type_node;
112         tree truthvalue_false_node;
113         tree truthvalue_true_node;
114
115         tree ptrdiff_type_node;
116
117         tree unsigned_char_type_node;
118         tree signed_char_type_node;
119         tree wchar_type_node;
120         tree signed_wchar_type_node;
121         tree unsigned_wchar_type_node;
122
123         tree float_type_node;
124         tree double_type_node;
125         tree long_double_type_node;
126
127         tree complex_integer_type_node;
128         tree complex_float_type_node;
129         tree complex_double_type_node;
130         tree complex_long_double_type_node;
131
132         tree intQI_type_node;
133         tree intHI_type_node;
134         tree intSI_type_node;
135         tree intDI_type_node;
136         tree intTI_type_node;
137
138         tree unsigned_intQI_type_node;
139         tree unsigned_intHI_type_node;
140         tree unsigned_intSI_type_node;
141         tree unsigned_intDI_type_node;
142         tree unsigned_intTI_type_node;
143
144         tree widest_integer_literal_type_node;
145         tree widest_unsigned_literal_type_node;
146
147    Nodes for types `void *' and `const void *'.
148
149         tree ptr_type_node, const_ptr_type_node;
150
151    Nodes for types `char *' and `const char *'.
152
153         tree string_type_node, const_string_type_node;
154
155    Type `char[SOMENUMBER]'.
156    Used when an array of char is needed and the size is irrelevant.
157
158         tree char_array_type_node;
159
160    Type `int[SOMENUMBER]' or something like it.
161    Used when an array of int needed and the size is irrelevant.
162
163         tree int_array_type_node;
164
165    Type `wchar_t[SOMENUMBER]' or something like it.
166    Used when a wide string literal is created.
167
168         tree wchar_array_type_node;
169
170    Type `int ()' -- used for implicit declaration of functions.
171
172         tree default_function_type;
173
174    A VOID_TYPE node, packaged in a TREE_LIST.
175
176         tree void_list_node;
177
178   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
179   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
180   VAR_DECLS, but C++ does.)
181
182         tree function_name_decl_node;
183         tree pretty_function_name_decl_node;
184         tree c99_function_name_decl_node;
185
186   Stack of nested function name VAR_DECLs.
187
188         tree saved_function_name_decls;
189
190 */
191
192 tree c_global_trees[CTI_MAX];
193
194 /* TRUE if a code represents a statement.  The front end init
195    langhook should take care of initialization of this array.  */
196
197 bool statement_code_p[MAX_TREE_CODES];
198 \f
199 /* Switches common to the C front ends.  */
200
201 /* Nonzero if prepreprocessing only.  */
202
203 int flag_preprocess_only;
204
205 /* Nonzero means don't output line number information.  */
206
207 char flag_no_line_commands;
208
209 /* Nonzero causes -E output not to be done, but directives such as
210    #define that have side effects are still obeyed.  */
211
212 char flag_no_output;
213
214 /* Nonzero means dump macros in some fashion.  */
215
216 char flag_dump_macros;
217
218 /* Nonzero means pass #include lines through to the output.  */
219
220 char flag_dump_includes;
221
222 /* Nonzero means process PCH files while preprocessing.  */
223
224 bool flag_pch_preprocess;
225
226 /* The file name to which we should write a precompiled header, or
227    NULL if no header will be written in this compile.  */
228
229 const char *pch_file;
230
231 /* Nonzero if an ISO standard was selected.  It rejects macros in the
232    user's namespace.  */
233 int flag_iso;
234
235 /* Nonzero if -undef was given.  It suppresses target built-in macros
236    and assertions.  */
237 int flag_undef;
238
239 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
240
241 int flag_no_builtin;
242
243 /* Nonzero means don't recognize the non-ANSI builtin functions.
244    -ansi sets this.  */
245
246 int flag_no_nonansi_builtin;
247
248 /* Nonzero means give `double' the same size as `float'.  */
249
250 int flag_short_double;
251
252 /* Nonzero means give `wchar_t' the same size as `short'.  */
253
254 int flag_short_wchar;
255
256 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
257 int flag_ms_extensions;
258
259 /* Nonzero means don't recognize the keyword `asm'.  */
260
261 int flag_no_asm;
262
263 /* Nonzero means give string constants the type `const char *', as mandated
264    by the standard.  */
265
266 int flag_const_strings;
267
268 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
269
270 int flag_signed_bitfields = 1;
271 int explicit_flag_signed_bitfields;
272
273 /* Nonzero means warn about deprecated conversion from string constant to
274    `char *'.  */
275
276 int warn_write_strings;
277
278 /* Warn about #pragma directives that are not recognized.  */
279
280 int warn_unknown_pragmas; /* Tri state variable.  */
281
282 /* Warn about format/argument anomalies in calls to formatted I/O functions
283    (*printf, *scanf, strftime, strfmon, etc.).  */
284
285 int warn_format;
286
287 /* Zero means that faster, ...NonNil variants of objc_msgSend...
288    calls will be used in ObjC; passing nil receivers to such calls
289    will most likely result in crashes.  */
290 int flag_nil_receivers = 1;
291
292 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
293    @try, etc.) in source code.  */
294 int flag_objc_exceptions = 0;
295
296 /* Nonzero means that we generate NeXT setjmp based exceptions.  */
297 int flag_objc_sjlj_exceptions = -1;
298
299 /* Nonzero means that code generation will be altered to support
300    "zero-link" execution.  This currently affects ObjC only, but may
301    affect other languages in the future.  */
302 int flag_zero_link = 0;
303
304 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
305    unit.  It will inform the ObjC runtime that class definition(s) herein
306    contained are to replace one(s) previously loaded.  */
307 int flag_replace_objc_classes = 0;
308
309 /* C/ObjC language option variables.  */
310
311
312 /* Nonzero means allow type mismatches in conditional expressions;
313    just make their values `void'.  */
314
315 int flag_cond_mismatch;
316
317 /* Nonzero means enable C89 Amendment 1 features.  */
318
319 int flag_isoc94;
320
321 /* Nonzero means use the ISO C99 dialect of C.  */
322
323 int flag_isoc99;
324
325 /* Nonzero means that we have builtin functions, and main is an int.  */
326
327 int flag_hosted = 1;
328
329 /* Warn if main is suspicious.  */
330
331 int warn_main;
332
333
334 /* ObjC language option variables.  */
335
336
337 /* Open and close the file for outputting class declarations, if
338    requested (ObjC).  */
339
340 int flag_gen_declaration;
341
342 /* Generate code for GNU or NeXT runtime environment.  */
343
344 #ifdef NEXT_OBJC_RUNTIME
345 int flag_next_runtime = 1;
346 #else
347 int flag_next_runtime = 0;
348 #endif
349
350 /* Tells the compiler that this is a special run.  Do not perform any
351    compiling, instead we are to test some platform dependent features
352    and output a C header file with appropriate definitions.  */
353
354 int print_struct_values;
355
356 /* ???.  Undocumented.  */
357
358 const char *constant_string_class_name;
359
360
361 /* C++ language option variables.  */
362
363
364 /* Nonzero means don't recognize any extension keywords.  */
365
366 int flag_no_gnu_keywords;
367
368 /* Nonzero means do emit exported implementations of functions even if
369    they can be inlined.  */
370
371 int flag_implement_inlines = 1;
372
373 /* Nonzero means that implicit instantiations will be emitted if needed.  */
374
375 int flag_implicit_templates = 1;
376
377 /* Nonzero means that implicit instantiations of inline templates will be
378    emitted if needed, even if instantiations of non-inline templates
379    aren't.  */
380
381 int flag_implicit_inline_templates = 1;
382
383 /* Nonzero means generate separate instantiation control files and
384    juggle them at link time.  */
385
386 int flag_use_repository;
387
388 /* Nonzero if we want to issue diagnostics that the standard says are not
389    required.  */
390
391 int flag_optional_diags = 1;
392
393 /* Nonzero means we should attempt to elide constructors when possible.  */
394
395 int flag_elide_constructors = 1;
396
397 /* Nonzero means that member functions defined in class scope are
398    inline by default.  */
399
400 int flag_default_inline = 1;
401
402 /* Controls whether compiler generates 'type descriptor' that give
403    run-time type information.  */
404
405 int flag_rtti = 1;
406
407 /* Nonzero if we want to conserve space in the .o files.  We do this
408    by putting uninitialized data and runtime initialized data into
409    .common instead of .data at the expense of not flagging multiple
410    definitions.  */
411
412 int flag_conserve_space;
413
414 /* Nonzero if we want to obey access control semantics.  */
415
416 int flag_access_control = 1;
417
418 /* Nonzero if we want to check the return value of new and avoid calling
419    constructors if it is a null pointer.  */
420
421 int flag_check_new;
422
423 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
424    initialization variables.
425    0: Old rules, set by -fno-for-scope.
426    2: New ISO rules, set by -ffor-scope.
427    1: Try to implement new ISO rules, but with backup compatibility
428    (and warnings).  This is the default, for now.  */
429
430 int flag_new_for_scope = 1;
431
432 /* Nonzero if we want to emit defined symbols with common-like linkage as
433    weak symbols where possible, in order to conform to C++ semantics.
434    Otherwise, emit them as local symbols.  */
435
436 int flag_weak = 1;
437
438 /* 0 means we want the preprocessor to not emit line directives for
439    the current working directory.  1 means we want it to do it.  -1
440    means we should decide depending on whether debugging information
441    is being emitted or not.  */
442
443 int flag_working_directory = -1;
444
445 /* Nonzero to use __cxa_atexit, rather than atexit, to register
446    destructors for local statics and global objects.  */
447
448 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
449
450 /* Nonzero means make the default pedwarns warnings instead of errors.
451    The value of this flag is ignored if -pedantic is specified.  */
452
453 int flag_permissive;
454
455 /* Nonzero means to implement standard semantics for exception
456    specifications, calling unexpected if an exception is thrown that
457    doesn't match the specification.  Zero means to treat them as
458    assertions and optimize accordingly, but not check them.  */
459
460 int flag_enforce_eh_specs = 1;
461
462 /* Nonzero means warn about implicit declarations.  */
463
464 int warn_implicit = 1;
465
466 /* Maximum template instantiation depth.  This limit is rather
467    arbitrary, but it exists to limit the time it takes to notice
468    infinite template instantiations.  */
469
470 int max_tinst_depth = 500;
471
472
473
474 /* The elements of `ridpointers' are identifier nodes for the reserved
475    type names and storage classes.  It is indexed by a RID_... value.  */
476 tree *ridpointers;
477
478 tree (*make_fname_decl) (tree, int);
479
480 /* If non-NULL, the address of a language-specific function that
481    returns 1 for language-specific statement codes.  */
482 int (*lang_statement_code_p) (enum tree_code);
483
484 /* If non-NULL, the address of a language-specific function that takes
485    any action required right before expand_function_end is called.  */
486 void (*lang_expand_function_end) (void);
487
488 /* Nonzero means the expression being parsed will never be evaluated.
489    This is a count, since unevaluated expressions can nest.  */
490 int skip_evaluation;
491
492 /* Information about how a function name is generated.  */
493 struct fname_var_t
494 {
495   tree *const decl;     /* pointer to the VAR_DECL.  */
496   const unsigned rid;   /* RID number for the identifier.  */
497   const int pretty;     /* How pretty is it? */
498 };
499
500 /* The three ways of getting then name of the current function.  */
501
502 const struct fname_var_t fname_vars[] =
503 {
504   /* C99 compliant __func__, must be first.  */
505   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
506   /* GCC __FUNCTION__ compliant.  */
507   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
508   /* GCC __PRETTY_FUNCTION__ compliant.  */
509   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
510   {NULL, 0, 0},
511 };
512
513 static int constant_fits_type_p (tree, tree);
514 static tree check_case_value (tree);
515 static bool check_case_bounds (tree, tree, tree *, tree *);
516
517 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
518 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
519 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_always_inline_attribute (tree *, tree, tree, int,
523                                             bool *);
524 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_transparent_union_attribute (tree *, tree, tree,
528                                                 int, bool *);
529 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
532 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
533 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
535 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
536 static tree handle_visibility_attribute (tree *, tree, tree, int,
537                                          bool *);
538 static tree handle_tls_model_attribute (tree *, tree, tree, int,
539                                         bool *);
540 static tree handle_no_instrument_function_attribute (tree *, tree,
541                                                      tree, int, bool *);
542 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
543 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
544                                              bool *);
545 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
546 static tree handle_deprecated_attribute (tree *, tree, tree, int,
547                                          bool *);
548 static tree handle_vector_size_attribute (tree *, tree, tree, int,
549                                           bool *);
550 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
552 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
553 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
554                                                  bool *);
555
556 static void check_function_nonnull (tree, tree);
557 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
558 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
559 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
560 static int resort_field_decl_cmp (const void *, const void *);
561
562 /* Table of machine-independent attributes common to all C-like languages.  */
563 const struct attribute_spec c_common_attribute_table[] =
564 {
565   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
566   { "packed",                 0, 0, false, false, false,
567                               handle_packed_attribute },
568   { "nocommon",               0, 0, true,  false, false,
569                               handle_nocommon_attribute },
570   { "common",                 0, 0, true,  false, false,
571                               handle_common_attribute },
572   /* FIXME: logically, noreturn attributes should be listed as
573      "false, true, true" and apply to function types.  But implementing this
574      would require all the places in the compiler that use TREE_THIS_VOLATILE
575      on a decl to identify non-returning functions to be located and fixed
576      to check the function type instead.  */
577   { "noreturn",               0, 0, true,  false, false,
578                               handle_noreturn_attribute },
579   { "volatile",               0, 0, true,  false, false,
580                               handle_noreturn_attribute },
581   { "noinline",               0, 0, true,  false, false,
582                               handle_noinline_attribute },
583   { "always_inline",          0, 0, true,  false, false,
584                               handle_always_inline_attribute },
585   { "used",                   0, 0, true,  false, false,
586                               handle_used_attribute },
587   { "unused",                 0, 0, false, false, false,
588                               handle_unused_attribute },
589   /* The same comments as for noreturn attributes apply to const ones.  */
590   { "const",                  0, 0, true,  false, false,
591                               handle_const_attribute },
592   { "transparent_union",      0, 0, false, false, false,
593                               handle_transparent_union_attribute },
594   { "constructor",            0, 0, true,  false, false,
595                               handle_constructor_attribute },
596   { "destructor",             0, 0, true,  false, false,
597                               handle_destructor_attribute },
598   { "mode",                   1, 1, false,  true, false,
599                               handle_mode_attribute },
600   { "section",                1, 1, true,  false, false,
601                               handle_section_attribute },
602   { "aligned",                0, 1, false, false, false,
603                               handle_aligned_attribute },
604   { "weak",                   0, 0, true,  false, false,
605                               handle_weak_attribute },
606   { "alias",                  1, 1, true,  false, false,
607                               handle_alias_attribute },
608   { "no_instrument_function", 0, 0, true,  false, false,
609                               handle_no_instrument_function_attribute },
610   { "malloc",                 0, 0, true,  false, false,
611                               handle_malloc_attribute },
612   { "no_stack_limit",         0, 0, true,  false, false,
613                               handle_no_limit_stack_attribute },
614   { "pure",                   0, 0, true,  false, false,
615                               handle_pure_attribute },
616   { "deprecated",             0, 0, false, false, false,
617                               handle_deprecated_attribute },
618   { "vector_size",            1, 1, false, true, false,
619                               handle_vector_size_attribute },
620   { "visibility",             1, 1, false, false, false,
621                               handle_visibility_attribute },
622   { "tls_model",              1, 1, true,  false, false,
623                               handle_tls_model_attribute },
624   { "nonnull",                0, -1, false, true, true,
625                               handle_nonnull_attribute },
626   { "nothrow",                0, 0, true,  false, false,
627                               handle_nothrow_attribute },
628   { "may_alias",              0, 0, false, true, false, NULL },
629   { "cleanup",                1, 1, true, false, false,
630                               handle_cleanup_attribute },
631   { "warn_unused_result",     0, 0, false, true, true,
632                               handle_warn_unused_result_attribute },
633   { NULL,                     0, 0, false, false, false, NULL }
634 };
635
636 /* Give the specifications for the format attributes, used by C and all
637    descendants.  */
638
639 const struct attribute_spec c_common_format_attribute_table[] =
640 {
641   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
642   { "format",                 3, 3, false, true,  true,
643                               handle_format_attribute },
644   { "format_arg",             1, 1, false, true,  true,
645                               handle_format_arg_attribute },
646   { NULL,                     0, 0, false, false, false, NULL }
647 };
648
649 /* Push current bindings for the function name VAR_DECLS.  */
650
651 void
652 start_fname_decls (void)
653 {
654   unsigned ix;
655   tree saved = NULL_TREE;
656
657   for (ix = 0; fname_vars[ix].decl; ix++)
658     {
659       tree decl = *fname_vars[ix].decl;
660
661       if (decl)
662         {
663           saved = tree_cons (decl, build_int_2 (ix, 0), saved);
664           *fname_vars[ix].decl = NULL_TREE;
665         }
666     }
667   if (saved || saved_function_name_decls)
668     /* Normally they'll have been NULL, so only push if we've got a
669        stack, or they are non-NULL.  */
670     saved_function_name_decls = tree_cons (saved, NULL_TREE,
671                                            saved_function_name_decls);
672 }
673
674 /* Finish up the current bindings, adding them into the current function's
675    statement tree.  This must be done _before_ finish_stmt_tree is called.
676    If there is no current function, we must be at file scope and no statements
677    are involved. Pop the previous bindings.  */
678
679 void
680 finish_fname_decls (void)
681 {
682   unsigned ix;
683   tree stmts = NULL_TREE;
684   tree stack = saved_function_name_decls;
685
686   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
687     append_to_statement_list (TREE_VALUE (stack), &stmts);
688
689   if (stmts)
690     {
691       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
692
693       if (TREE_CODE (*bodyp) == BIND_EXPR)
694         bodyp = &BIND_EXPR_BODY (*bodyp);
695
696       append_to_statement_list (*bodyp, &stmts);
697       *bodyp = stmts;
698     }
699
700   for (ix = 0; fname_vars[ix].decl; ix++)
701     *fname_vars[ix].decl = NULL_TREE;
702
703   if (stack)
704     {
705       /* We had saved values, restore them.  */
706       tree saved;
707
708       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
709         {
710           tree decl = TREE_PURPOSE (saved);
711           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
712
713           *fname_vars[ix].decl = decl;
714         }
715       stack = TREE_CHAIN (stack);
716     }
717   saved_function_name_decls = stack;
718 }
719
720 /* Return the text name of the current function, suitably prettified
721    by PRETTY_P.  Return string must be freed by caller.  */
722
723 const char *
724 fname_as_string (int pretty_p)
725 {
726   const char *name = "top level";
727   char *namep;
728   int vrb = 2;
729
730   if (! pretty_p)
731     {
732       name = "";
733       vrb = 0;
734     }
735
736   if (current_function_decl)
737     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
738
739   if (c_lex_string_translate)
740     {
741       int len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
742       cpp_string cstr = { 0, 0 }, strname;
743
744       namep = XNEWVEC (char, len);
745       snprintf (namep, len, "\"%s\"", name);
746       strname.text = (unsigned char *) namep;
747       strname.len = len - 1;
748
749       if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
750         return (char *) cstr.text;
751     }
752   else
753     namep = xstrdup (name);
754
755   return namep;
756 }
757
758 /* Expand DECL if it declares an entity not handled by the
759    common code.  */
760
761 int
762 c_expand_decl (tree decl)
763 {
764   if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
765     {
766       /* Let the back-end know about this variable.  */
767       if (!anon_aggr_type_p (TREE_TYPE (decl)))
768         emit_local_var (decl);
769       else
770         expand_anon_union_decl (decl, NULL_TREE,
771                                 DECL_ANON_UNION_ELEMS (decl));
772     }
773   else
774     return 0;
775
776   return 1;
777 }
778
779
780 /* Return the VAR_DECL for a const char array naming the current
781    function. If the VAR_DECL has not yet been created, create it
782    now. RID indicates how it should be formatted and IDENTIFIER_NODE
783    ID is its name (unfortunately C and C++ hold the RID values of
784    keywords in different places, so we can't derive RID from ID in
785    this language independent code.  */
786
787 tree
788 fname_decl (unsigned int rid, tree id)
789 {
790   unsigned ix;
791   tree decl = NULL_TREE;
792
793   for (ix = 0; fname_vars[ix].decl; ix++)
794     if (fname_vars[ix].rid == rid)
795       break;
796
797   decl = *fname_vars[ix].decl;
798   if (!decl)
799     {
800       /* If a tree is built here, it would normally have the lineno of
801          the current statement.  Later this tree will be moved to the
802          beginning of the function and this line number will be wrong.
803          To avoid this problem set the lineno to 0 here; that prevents
804          it from appearing in the RTL.  */
805       tree stmts;
806       location_t saved_location = input_location;
807 #ifdef USE_MAPPED_LOCATION
808       input_location = UNKNOWN_LOCATION;
809 #else
810       input_line = 0;
811 #endif
812
813       stmts = push_stmt_list ();
814       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
815       stmts = pop_stmt_list (stmts);
816       if (!IS_EMPTY_STMT (stmts))
817         saved_function_name_decls
818           = tree_cons (decl, stmts, saved_function_name_decls);
819       *fname_vars[ix].decl = decl;
820       input_location = saved_location;
821     }
822   if (!ix && !current_function_decl)
823     pedwarn ("%J'%D' is not defined outside of function scope", decl, decl);
824
825   return decl;
826 }
827
828 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
829
830 tree
831 fix_string_type (tree value)
832 {
833   const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
834   const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
835   const int nchars_max = flag_isoc99 ? 4095 : 509;
836   int length = TREE_STRING_LENGTH (value);
837   int nchars;
838
839   /* Compute the number of elements, for the array type.  */
840   nchars = wide_flag ? length / wchar_bytes : length;
841
842   if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
843     pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
844              nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
845
846   /* Create the array type for the string constant.
847      -Wwrite-strings says make the string constant an array of const char
848      so that copying it to a non-const pointer will get a warning.
849      For C++, this is the standard behavior.  */
850   if (flag_const_strings)
851     {
852       tree elements
853         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
854                               1, 0);
855       TREE_TYPE (value)
856         = build_array_type (elements,
857                             build_index_type (build_int_2 (nchars - 1, 0)));
858     }
859   else
860     TREE_TYPE (value)
861       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
862                           build_index_type (build_int_2 (nchars - 1, 0)));
863
864   TREE_CONSTANT (value) = 1;
865   TREE_INVARIANT (value) = 1;
866   TREE_READONLY (value) = 1;
867   TREE_STATIC (value) = 1;
868   return value;
869 }
870 \f
871 /* Print a warning if a constant expression had overflow in folding.
872    Invoke this function on every expression that the language
873    requires to be a constant expression.
874    Note the ANSI C standard says it is erroneous for a
875    constant expression to overflow.  */
876
877 void
878 constant_expression_warning (tree value)
879 {
880   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
881        || TREE_CODE (value) == VECTOR_CST
882        || TREE_CODE (value) == COMPLEX_CST)
883       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
884     pedwarn ("overflow in constant expression");
885 }
886
887 /* Print a warning if an expression had overflow in folding.
888    Invoke this function on every expression that
889    (1) appears in the source code, and
890    (2) might be a constant expression that overflowed, and
891    (3) is not already checked by convert_and_check;
892    however, do not invoke this function on operands of explicit casts.  */
893
894 void
895 overflow_warning (tree value)
896 {
897   if ((TREE_CODE (value) == INTEGER_CST
898        || (TREE_CODE (value) == COMPLEX_CST
899            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
900       && TREE_OVERFLOW (value))
901     {
902       TREE_OVERFLOW (value) = 0;
903       if (skip_evaluation == 0)
904         warning ("integer overflow in expression");
905     }
906   else if ((TREE_CODE (value) == REAL_CST
907             || (TREE_CODE (value) == COMPLEX_CST
908                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
909            && TREE_OVERFLOW (value))
910     {
911       TREE_OVERFLOW (value) = 0;
912       if (skip_evaluation == 0)
913         warning ("floating point overflow in expression");
914     }
915   else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
916     {
917       TREE_OVERFLOW (value) = 0;
918       if (skip_evaluation == 0)
919         warning ("vector overflow in expression");
920     }
921 }
922
923 /* Print a warning if a large constant is truncated to unsigned,
924    or if -Wconversion is used and a constant < 0 is converted to unsigned.
925    Invoke this function on every expression that might be implicitly
926    converted to an unsigned type.  */
927
928 void
929 unsigned_conversion_warning (tree result, tree operand)
930 {
931   tree type = TREE_TYPE (result);
932
933   if (TREE_CODE (operand) == INTEGER_CST
934       && TREE_CODE (type) == INTEGER_TYPE
935       && TYPE_UNSIGNED (type)
936       && skip_evaluation == 0
937       && !int_fits_type_p (operand, type))
938     {
939       if (!int_fits_type_p (operand, c_common_signed_type (type)))
940         /* This detects cases like converting -129 or 256 to unsigned char.  */
941         warning ("large integer implicitly truncated to unsigned type");
942       else if (warn_conversion)
943         warning ("negative integer implicitly converted to unsigned type");
944     }
945 }
946
947 /* Nonzero if constant C has a value that is permissible
948    for type TYPE (an INTEGER_TYPE).  */
949
950 static int
951 constant_fits_type_p (tree c, tree type)
952 {
953   if (TREE_CODE (c) == INTEGER_CST)
954     return int_fits_type_p (c, type);
955
956   c = convert (type, c);
957   return !TREE_OVERFLOW (c);
958 }
959
960 /* Nonzero if vector types T1 and T2 can be converted to each other
961    without an explicit cast.  */
962 int
963 vector_types_convertible_p (tree t1, tree t2)
964 {
965   return targetm.vector_opaque_p (t1)
966          || targetm.vector_opaque_p (t2)
967          || (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
968              && INTEGRAL_TYPE_P (TREE_TYPE (t1))
969                 == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
970 }
971
972 /* Convert EXPR to TYPE, warning about conversion problems with constants.
973    Invoke this function on every expression that is converted implicitly,
974    i.e. because of language rules and not because of an explicit cast.  */
975
976 tree
977 convert_and_check (tree type, tree expr)
978 {
979   tree t = convert (type, expr);
980   if (TREE_CODE (t) == INTEGER_CST)
981     {
982       if (TREE_OVERFLOW (t))
983         {
984           TREE_OVERFLOW (t) = 0;
985
986           /* Do not diagnose overflow in a constant expression merely
987              because a conversion overflowed.  */
988           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
989
990           /* No warning for converting 0x80000000 to int.  */
991           if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
992                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
993                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
994             /* If EXPR fits in the unsigned version of TYPE,
995                don't warn unless pedantic.  */
996             if ((pedantic
997                  || TYPE_UNSIGNED (type)
998                  || ! constant_fits_type_p (expr,
999                                             c_common_unsigned_type (type)))
1000                 && skip_evaluation == 0)
1001               warning ("overflow in implicit constant conversion");
1002         }
1003       else
1004         unsigned_conversion_warning (t, expr);
1005     }
1006   return t;
1007 }
1008 \f
1009 /* A node in a list that describes references to variables (EXPR), which are
1010    either read accesses if WRITER is zero, or write accesses, in which case
1011    WRITER is the parent of EXPR.  */
1012 struct tlist
1013 {
1014   struct tlist *next;
1015   tree expr, writer;
1016 };
1017
1018 /* Used to implement a cache the results of a call to verify_tree.  We only
1019    use this for SAVE_EXPRs.  */
1020 struct tlist_cache
1021 {
1022   struct tlist_cache *next;
1023   struct tlist *cache_before_sp;
1024   struct tlist *cache_after_sp;
1025   tree expr;
1026 };
1027
1028 /* Obstack to use when allocating tlist structures, and corresponding
1029    firstobj.  */
1030 static struct obstack tlist_obstack;
1031 static char *tlist_firstobj = 0;
1032
1033 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1034    warnings.  */
1035 static struct tlist *warned_ids;
1036 /* SAVE_EXPRs need special treatment.  We process them only once and then
1037    cache the results.  */
1038 static struct tlist_cache *save_expr_cache;
1039
1040 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1041 static void merge_tlist (struct tlist **, struct tlist *, int);
1042 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1043 static int warning_candidate_p (tree);
1044 static void warn_for_collisions (struct tlist *);
1045 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1046 static struct tlist *new_tlist (struct tlist *, tree, tree);
1047
1048 /* Create a new struct tlist and fill in its fields.  */
1049 static struct tlist *
1050 new_tlist (struct tlist *next, tree t, tree writer)
1051 {
1052   struct tlist *l;
1053   l = XOBNEW (&tlist_obstack, struct tlist);
1054   l->next = next;
1055   l->expr = t;
1056   l->writer = writer;
1057   return l;
1058 }
1059
1060 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1061    is nonnull, we ignore any node we find which has a writer equal to it.  */
1062
1063 static void
1064 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1065 {
1066   while (add)
1067     {
1068       struct tlist *next = add->next;
1069       if (! copy)
1070         add->next = *to;
1071       if (! exclude_writer || add->writer != exclude_writer)
1072         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1073       add = next;
1074     }
1075 }
1076
1077 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1078    each variable that already exists in TO, no new node is added; however if
1079    there is a write access recorded in ADD, and an occurrence on TO is only
1080    a read access, then the occurrence in TO will be modified to record the
1081    write.  */
1082
1083 static void
1084 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1085 {
1086   struct tlist **end = to;
1087
1088   while (*end)
1089     end = &(*end)->next;
1090
1091   while (add)
1092     {
1093       int found = 0;
1094       struct tlist *tmp2;
1095       struct tlist *next = add->next;
1096
1097       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1098         if (tmp2->expr == add->expr)
1099           {
1100             found = 1;
1101             if (! tmp2->writer)
1102               tmp2->writer = add->writer;
1103           }
1104       if (! found)
1105         {
1106           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1107           end = &(*end)->next;
1108           *end = 0;
1109         }
1110       add = next;
1111     }
1112 }
1113
1114 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1115    references in list LIST conflict with it, excluding reads if ONLY writers
1116    is nonzero.  */
1117
1118 static void
1119 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1120                        int only_writes)
1121 {
1122   struct tlist *tmp;
1123
1124   /* Avoid duplicate warnings.  */
1125   for (tmp = warned_ids; tmp; tmp = tmp->next)
1126     if (tmp->expr == written)
1127       return;
1128
1129   while (list)
1130     {
1131       if (list->expr == written
1132           && list->writer != writer
1133           && (! only_writes || list->writer)
1134           && DECL_NAME (list->expr))
1135         {
1136           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1137           warning ("operation on `%s' may be undefined",
1138                    IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1139         }
1140       list = list->next;
1141     }
1142 }
1143
1144 /* Given a list LIST of references to variables, find whether any of these
1145    can cause conflicts due to missing sequence points.  */
1146
1147 static void
1148 warn_for_collisions (struct tlist *list)
1149 {
1150   struct tlist *tmp;
1151
1152   for (tmp = list; tmp; tmp = tmp->next)
1153     {
1154       if (tmp->writer)
1155         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1156     }
1157 }
1158
1159 /* Return nonzero if X is a tree that can be verified by the sequence point
1160    warnings.  */
1161 static int
1162 warning_candidate_p (tree x)
1163 {
1164   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1165 }
1166
1167 /* Walk the tree X, and record accesses to variables.  If X is written by the
1168    parent tree, WRITER is the parent.
1169    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1170    expression or its only operand forces a sequence point, then everything up
1171    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1172    in PNO_SP.
1173    Once we return, we will have emitted warnings if any subexpression before
1174    such a sequence point could be undefined.  On a higher level, however, the
1175    sequence point may not be relevant, and we'll merge the two lists.
1176
1177    Example: (b++, a) + b;
1178    The call that processes the COMPOUND_EXPR will store the increment of B
1179    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1180    processes the PLUS_EXPR will need to merge the two lists so that
1181    eventually, all accesses end up on the same list (and we'll warn about the
1182    unordered subexpressions b++ and b.
1183
1184    A note on merging.  If we modify the former example so that our expression
1185    becomes
1186      (b++, b) + a
1187    care must be taken not simply to add all three expressions into the final
1188    PNO_SP list.  The function merge_tlist takes care of that by merging the
1189    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1190    way, so that no more than one access to B is recorded.  */
1191
1192 static void
1193 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1194              tree writer)
1195 {
1196   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1197   enum tree_code code;
1198   char cl;
1199
1200   /* X may be NULL if it is the operand of an empty statement expression
1201      ({ }).  */
1202   if (x == NULL)
1203     return;
1204
1205  restart:
1206   code = TREE_CODE (x);
1207   cl = TREE_CODE_CLASS (code);
1208
1209   if (warning_candidate_p (x))
1210     {
1211       *pno_sp = new_tlist (*pno_sp, x, writer);
1212       return;
1213     }
1214
1215   switch (code)
1216     {
1217     case CONSTRUCTOR:
1218       return;
1219
1220     case COMPOUND_EXPR:
1221     case TRUTH_ANDIF_EXPR:
1222     case TRUTH_ORIF_EXPR:
1223       tmp_before = tmp_nosp = tmp_list3 = 0;
1224       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1225       warn_for_collisions (tmp_nosp);
1226       merge_tlist (pbefore_sp, tmp_before, 0);
1227       merge_tlist (pbefore_sp, tmp_nosp, 0);
1228       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1229       merge_tlist (pbefore_sp, tmp_list3, 0);
1230       return;
1231
1232     case COND_EXPR:
1233       tmp_before = tmp_list2 = 0;
1234       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1235       warn_for_collisions (tmp_list2);
1236       merge_tlist (pbefore_sp, tmp_before, 0);
1237       merge_tlist (pbefore_sp, tmp_list2, 1);
1238
1239       tmp_list3 = tmp_nosp = 0;
1240       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1241       warn_for_collisions (tmp_nosp);
1242       merge_tlist (pbefore_sp, tmp_list3, 0);
1243
1244       tmp_list3 = tmp_list2 = 0;
1245       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1246       warn_for_collisions (tmp_list2);
1247       merge_tlist (pbefore_sp, tmp_list3, 0);
1248       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1249          two first, to avoid warning for (a ? b++ : b++).  */
1250       merge_tlist (&tmp_nosp, tmp_list2, 0);
1251       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1252       return;
1253
1254     case PREDECREMENT_EXPR:
1255     case PREINCREMENT_EXPR:
1256     case POSTDECREMENT_EXPR:
1257     case POSTINCREMENT_EXPR:
1258       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1259       return;
1260
1261     case MODIFY_EXPR:
1262       tmp_before = tmp_nosp = tmp_list3 = 0;
1263       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1264       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1265       /* Expressions inside the LHS are not ordered wrt. the sequence points
1266          in the RHS.  Example:
1267            *a = (a++, 2)
1268          Despite the fact that the modification of "a" is in the before_sp
1269          list (tmp_before), it conflicts with the use of "a" in the LHS.
1270          We can handle this by adding the contents of tmp_list3
1271          to those of tmp_before, and redoing the collision warnings for that
1272          list.  */
1273       add_tlist (&tmp_before, tmp_list3, x, 1);
1274       warn_for_collisions (tmp_before);
1275       /* Exclude the LHS itself here; we first have to merge it into the
1276          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1277          didn't exclude the LHS, we'd get it twice, once as a read and once
1278          as a write.  */
1279       add_tlist (pno_sp, tmp_list3, x, 0);
1280       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1281
1282       merge_tlist (pbefore_sp, tmp_before, 0);
1283       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1284         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1285       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1286       return;
1287
1288     case CALL_EXPR:
1289       /* We need to warn about conflicts among arguments and conflicts between
1290          args and the function address.  Side effects of the function address,
1291          however, are not ordered by the sequence point of the call.  */
1292       tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1293       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1294       if (TREE_OPERAND (x, 1))
1295         verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1296       merge_tlist (&tmp_list3, tmp_list2, 0);
1297       add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1298       add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1299       warn_for_collisions (tmp_before);
1300       add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1301       return;
1302
1303     case TREE_LIST:
1304       /* Scan all the list, e.g. indices of multi dimensional array.  */
1305       while (x)
1306         {
1307           tmp_before = tmp_nosp = 0;
1308           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1309           merge_tlist (&tmp_nosp, tmp_before, 0);
1310           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1311           x = TREE_CHAIN (x);
1312         }
1313       return;
1314
1315     case SAVE_EXPR:
1316       {
1317         struct tlist_cache *t;
1318         for (t = save_expr_cache; t; t = t->next)
1319           if (t->expr == x)
1320             break;
1321
1322         if (! t)
1323           {
1324             t = XOBNEW (&tlist_obstack, struct tlist_cache);
1325             t->next = save_expr_cache;
1326             t->expr = x;
1327             save_expr_cache = t;
1328
1329             tmp_before = tmp_nosp = 0;
1330             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1331             warn_for_collisions (tmp_nosp);
1332
1333             tmp_list3 = 0;
1334             while (tmp_nosp)
1335               {
1336                 struct tlist *t = tmp_nosp;
1337                 tmp_nosp = t->next;
1338                 merge_tlist (&tmp_list3, t, 0);
1339               }
1340             t->cache_before_sp = tmp_before;
1341             t->cache_after_sp = tmp_list3;
1342           }
1343         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1344         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1345         return;
1346       }
1347     default:
1348       break;
1349     }
1350
1351   if (cl == '1')
1352     {
1353       if (first_rtl_op (code) == 0)
1354         return;
1355       x = TREE_OPERAND (x, 0);
1356       writer = 0;
1357       goto restart;
1358     }
1359
1360   switch (cl)
1361     {
1362     case 'r':
1363     case '<':
1364     case '2':
1365     case 'e':
1366     case 's':
1367     case 'x':
1368       {
1369         int lp;
1370         int max = first_rtl_op (TREE_CODE (x));
1371         for (lp = 0; lp < max; lp++)
1372           {
1373             tmp_before = tmp_nosp = 0;
1374             verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1375             merge_tlist (&tmp_nosp, tmp_before, 0);
1376             add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1377           }
1378         break;
1379       }
1380     }
1381 }
1382
1383 /* Try to warn for undefined behavior in EXPR due to missing sequence
1384    points.  */
1385
1386 void
1387 verify_sequence_points (tree expr)
1388 {
1389   struct tlist *before_sp = 0, *after_sp = 0;
1390
1391   warned_ids = 0;
1392   save_expr_cache = 0;
1393   if (tlist_firstobj == 0)
1394     {
1395       gcc_obstack_init (&tlist_obstack);
1396       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1397     }
1398
1399   verify_tree (expr, &before_sp, &after_sp, 0);
1400   warn_for_collisions (after_sp);
1401   obstack_free (&tlist_obstack, tlist_firstobj);
1402 }
1403 \f
1404 /* Validate the expression after `case' and apply default promotions.  */
1405
1406 static tree
1407 check_case_value (tree value)
1408 {
1409   if (value == NULL_TREE)
1410     return value;
1411
1412   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1413   STRIP_TYPE_NOPS (value);
1414   /* In C++, the following is allowed:
1415
1416        const int i = 3;
1417        switch (...) { case i: ... }
1418
1419      So, we try to reduce the VALUE to a constant that way.  */
1420   if (c_dialect_cxx ())
1421     {
1422       value = decl_constant_value (value);
1423       STRIP_TYPE_NOPS (value);
1424       value = fold (value);
1425     }
1426
1427   if (TREE_CODE (value) != INTEGER_CST
1428       && value != error_mark_node)
1429     {
1430       error ("case label does not reduce to an integer constant");
1431       value = error_mark_node;
1432     }
1433   else
1434     /* Promote char or short to int.  */
1435     value = default_conversion (value);
1436
1437   constant_expression_warning (value);
1438
1439   return value;
1440 }
1441 \f
1442 /* See if the case values LOW and HIGH are in the range of the original
1443    type (ie. before the default conversion to int) of the switch testing
1444    expression.
1445    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1446    the type before promiting it.  CASE_LOW_P is a pointer to the lower
1447    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1448    if the case is not a case range.
1449    The caller has to make sure that we are not called with NULL for
1450    CASE_LOW_P (ie. the defualt case).
1451    Returns true if the case label is in range of ORIG_TYPE (satured or
1452    untouched) or false if the label is out of range.  */
1453
1454 static bool
1455 check_case_bounds (tree type, tree orig_type,
1456                    tree *case_low_p, tree *case_high_p)
1457 {
1458   tree min_value, max_value;
1459   tree case_low = *case_low_p;
1460   tree case_high = case_high_p ? *case_high_p : case_low;
1461
1462   /* If there was a problem with the original type, do nothing.  */
1463   if (orig_type == error_mark_node)
1464     return true;
1465
1466   min_value = TYPE_MIN_VALUE (orig_type);
1467   max_value = TYPE_MAX_VALUE (orig_type);
1468
1469   /* Case label is less than minimum for type.  */
1470   if (tree_int_cst_compare (case_low, min_value) < 0
1471       && tree_int_cst_compare (case_high, min_value) < 0)
1472     {
1473       warning ("case label value is less than minimum value for type");
1474       return false;
1475     }
1476
1477   /* Case value is greater than maximum for type.  */
1478   if (tree_int_cst_compare (case_low, max_value) > 0
1479       && tree_int_cst_compare (case_high, max_value) > 0)
1480     {
1481       warning ("case label value exceeds maximum value for type");
1482       return false;
1483     }
1484
1485   /* Saturate lower case label value to minimum.  */
1486   if (tree_int_cst_compare (case_high, min_value) >= 0
1487       && tree_int_cst_compare (case_low, min_value) < 0)
1488     {
1489       warning ("lower value in case label range"
1490                " less than minimum value for type");
1491       case_low = min_value;
1492     }
1493
1494   /* Saturate upper case label value to maximum.  */
1495   if (tree_int_cst_compare (case_low, max_value) <= 0
1496       && tree_int_cst_compare (case_high, max_value) > 0)
1497     {
1498       warning ("upper value in case label range"
1499                " exceeds maximum value for type");
1500       case_high = max_value;
1501     }
1502
1503   if (*case_low_p != case_low)
1504     *case_low_p = convert (type, case_low);
1505   if (case_high_p && *case_high_p != case_high)
1506     *case_high_p = convert (type, case_high);
1507
1508   return true;
1509 }
1510 \f
1511 /* Return an integer type with BITS bits of precision,
1512    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1513
1514 tree
1515 c_common_type_for_size (unsigned int bits, int unsignedp)
1516 {
1517   if (bits == TYPE_PRECISION (integer_type_node))
1518     return unsignedp ? unsigned_type_node : integer_type_node;
1519
1520   if (bits == TYPE_PRECISION (signed_char_type_node))
1521     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1522
1523   if (bits == TYPE_PRECISION (short_integer_type_node))
1524     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1525
1526   if (bits == TYPE_PRECISION (long_integer_type_node))
1527     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1528
1529   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1530     return (unsignedp ? long_long_unsigned_type_node
1531             : long_long_integer_type_node);
1532
1533   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1534     return (unsignedp ? widest_unsigned_literal_type_node
1535             : widest_integer_literal_type_node);
1536
1537   if (bits <= TYPE_PRECISION (intQI_type_node))
1538     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1539
1540   if (bits <= TYPE_PRECISION (intHI_type_node))
1541     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1542
1543   if (bits <= TYPE_PRECISION (intSI_type_node))
1544     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1545
1546   if (bits <= TYPE_PRECISION (intDI_type_node))
1547     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1548
1549   return 0;
1550 }
1551
1552 /* Used for communication between c_common_type_for_mode and
1553    c_register_builtin_type.  */
1554 static GTY(()) tree registered_builtin_types;
1555
1556 /* Return a data type that has machine mode MODE.
1557    If the mode is an integer,
1558    then UNSIGNEDP selects between signed and unsigned types.  */
1559
1560 tree
1561 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1562 {
1563   tree t;
1564
1565   if (mode == TYPE_MODE (integer_type_node))
1566     return unsignedp ? unsigned_type_node : integer_type_node;
1567
1568   if (mode == TYPE_MODE (signed_char_type_node))
1569     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1570
1571   if (mode == TYPE_MODE (short_integer_type_node))
1572     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1573
1574   if (mode == TYPE_MODE (long_integer_type_node))
1575     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1576
1577   if (mode == TYPE_MODE (long_long_integer_type_node))
1578     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1579
1580   if (mode == TYPE_MODE (widest_integer_literal_type_node))
1581     return unsignedp ? widest_unsigned_literal_type_node
1582                      : widest_integer_literal_type_node;
1583
1584   if (mode == QImode)
1585     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1586
1587   if (mode == HImode)
1588     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1589
1590   if (mode == SImode)
1591     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1592
1593   if (mode == DImode)
1594     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1595
1596 #if HOST_BITS_PER_WIDE_INT >= 64
1597   if (mode == TYPE_MODE (intTI_type_node))
1598     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1599 #endif
1600
1601   if (mode == TYPE_MODE (float_type_node))
1602     return float_type_node;
1603
1604   if (mode == TYPE_MODE (double_type_node))
1605     return double_type_node;
1606
1607   if (mode == TYPE_MODE (long_double_type_node))
1608     return long_double_type_node;
1609
1610   if (mode == TYPE_MODE (void_type_node))
1611     return void_type_node;
1612
1613   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1614     return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1615
1616   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1617     return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1618
1619   if (VECTOR_MODE_P (mode))
1620     {
1621       enum machine_mode inner_mode = GET_MODE_INNER (mode);
1622       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1623       if (inner_type != NULL_TREE)
1624         return build_vector_type_for_mode (inner_type, mode);
1625     }
1626
1627   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1628     if (TYPE_MODE (TREE_VALUE (t)) == mode)
1629       return TREE_VALUE (t);
1630
1631   return 0;
1632 }
1633
1634 /* Return an unsigned type the same as TYPE in other respects.  */
1635 tree
1636 c_common_unsigned_type (tree type)
1637 {
1638   tree type1 = TYPE_MAIN_VARIANT (type);
1639   if (type1 == signed_char_type_node || type1 == char_type_node)
1640     return unsigned_char_type_node;
1641   if (type1 == integer_type_node)
1642     return unsigned_type_node;
1643   if (type1 == short_integer_type_node)
1644     return short_unsigned_type_node;
1645   if (type1 == long_integer_type_node)
1646     return long_unsigned_type_node;
1647   if (type1 == long_long_integer_type_node)
1648     return long_long_unsigned_type_node;
1649   if (type1 == widest_integer_literal_type_node)
1650     return widest_unsigned_literal_type_node;
1651 #if HOST_BITS_PER_WIDE_INT >= 64
1652   if (type1 == intTI_type_node)
1653     return unsigned_intTI_type_node;
1654 #endif
1655   if (type1 == intDI_type_node)
1656     return unsigned_intDI_type_node;
1657   if (type1 == intSI_type_node)
1658     return unsigned_intSI_type_node;
1659   if (type1 == intHI_type_node)
1660     return unsigned_intHI_type_node;
1661   if (type1 == intQI_type_node)
1662     return unsigned_intQI_type_node;
1663
1664   return c_common_signed_or_unsigned_type (1, type);
1665 }
1666
1667 /* Return a signed type the same as TYPE in other respects.  */
1668
1669 tree
1670 c_common_signed_type (tree type)
1671 {
1672   tree type1 = TYPE_MAIN_VARIANT (type);
1673   if (type1 == unsigned_char_type_node || type1 == char_type_node)
1674     return signed_char_type_node;
1675   if (type1 == unsigned_type_node)
1676     return integer_type_node;
1677   if (type1 == short_unsigned_type_node)
1678     return short_integer_type_node;
1679   if (type1 == long_unsigned_type_node)
1680     return long_integer_type_node;
1681   if (type1 == long_long_unsigned_type_node)
1682     return long_long_integer_type_node;
1683   if (type1 == widest_unsigned_literal_type_node)
1684     return widest_integer_literal_type_node;
1685 #if HOST_BITS_PER_WIDE_INT >= 64
1686   if (type1 == unsigned_intTI_type_node)
1687     return intTI_type_node;
1688 #endif
1689   if (type1 == unsigned_intDI_type_node)
1690     return intDI_type_node;
1691   if (type1 == unsigned_intSI_type_node)
1692     return intSI_type_node;
1693   if (type1 == unsigned_intHI_type_node)
1694     return intHI_type_node;
1695   if (type1 == unsigned_intQI_type_node)
1696     return intQI_type_node;
1697
1698   return c_common_signed_or_unsigned_type (0, type);
1699 }
1700
1701 /* Return a type the same as TYPE except unsigned or
1702    signed according to UNSIGNEDP.  */
1703
1704 tree
1705 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1706 {
1707   if (! INTEGRAL_TYPE_P (type)
1708       || TYPE_UNSIGNED (type) == unsignedp)
1709     return type;
1710
1711   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1712      the precision; they have precision set to match their range, but
1713      may use a wider mode to match an ABI.  If we change modes, we may
1714      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
1715      the precision as well, so as to yield correct results for
1716      bit-field types.  C++ does not have these separate bit-field
1717      types, and producing a signed or unsigned variant of an
1718      ENUMERAL_TYPE may cause other problems as well.  */
1719
1720 #define TYPE_OK(node)                                                       \
1721   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
1722    && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1723   if (TYPE_OK (signed_char_type_node))
1724     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1725   if (TYPE_OK (integer_type_node))
1726     return unsignedp ? unsigned_type_node : integer_type_node;
1727   if (TYPE_OK (short_integer_type_node))
1728     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1729   if (TYPE_OK (long_integer_type_node))
1730     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1731   if (TYPE_OK (long_long_integer_type_node))
1732     return (unsignedp ? long_long_unsigned_type_node
1733             : long_long_integer_type_node);
1734   if (TYPE_OK (widest_integer_literal_type_node))
1735     return (unsignedp ? widest_unsigned_literal_type_node
1736             : widest_integer_literal_type_node);
1737
1738 #if HOST_BITS_PER_WIDE_INT >= 64
1739   if (TYPE_OK (intTI_type_node))
1740     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1741 #endif
1742   if (TYPE_OK (intDI_type_node))
1743     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1744   if (TYPE_OK (intSI_type_node))
1745     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1746   if (TYPE_OK (intHI_type_node))
1747     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1748   if (TYPE_OK (intQI_type_node))
1749     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1750 #undef TYPE_OK
1751
1752   if (c_dialect_cxx ())
1753     return type;
1754   else
1755     return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1756 }
1757
1758 /* The C version of the register_builtin_type langhook.  */
1759
1760 void
1761 c_register_builtin_type (tree type, const char* name)
1762 {
1763   tree decl;
1764
1765   decl = build_decl (TYPE_DECL, get_identifier (name), type);
1766   DECL_ARTIFICIAL (decl) = 1;
1767   if (!TYPE_NAME (type))
1768     TYPE_NAME (type) = decl;
1769   pushdecl (decl);
1770
1771   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1772 }
1773
1774 \f
1775 /* Return the minimum number of bits needed to represent VALUE in a
1776    signed or unsigned type, UNSIGNEDP says which.  */
1777
1778 unsigned int
1779 min_precision (tree value, int unsignedp)
1780 {
1781   int log;
1782
1783   /* If the value is negative, compute its negative minus 1.  The latter
1784      adjustment is because the absolute value of the largest negative value
1785      is one larger than the largest positive value.  This is equivalent to
1786      a bit-wise negation, so use that operation instead.  */
1787
1788   if (tree_int_cst_sgn (value) < 0)
1789     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1790
1791   /* Return the number of bits needed, taking into account the fact
1792      that we need one more bit for a signed than unsigned type.  */
1793
1794   if (integer_zerop (value))
1795     log = 0;
1796   else
1797     log = tree_floor_log2 (value);
1798
1799   return log + 1 + ! unsignedp;
1800 }
1801 \f
1802 /* Print an error message for invalid operands to arith operation
1803    CODE.  NOP_EXPR is used as a special case (see
1804    c_common_truthvalue_conversion).  */
1805
1806 void
1807 binary_op_error (enum tree_code code)
1808 {
1809   const char *opname;
1810
1811   switch (code)
1812     {
1813     case NOP_EXPR:
1814       error ("invalid truth-value expression");
1815       return;
1816
1817     case PLUS_EXPR:
1818       opname = "+"; break;
1819     case MINUS_EXPR:
1820       opname = "-"; break;
1821     case MULT_EXPR:
1822       opname = "*"; break;
1823     case MAX_EXPR:
1824       opname = "max"; break;
1825     case MIN_EXPR:
1826       opname = "min"; break;
1827     case EQ_EXPR:
1828       opname = "=="; break;
1829     case NE_EXPR:
1830       opname = "!="; break;
1831     case LE_EXPR:
1832       opname = "<="; break;
1833     case GE_EXPR:
1834       opname = ">="; break;
1835     case LT_EXPR:
1836       opname = "<"; break;
1837     case GT_EXPR:
1838       opname = ">"; break;
1839     case LSHIFT_EXPR:
1840       opname = "<<"; break;
1841     case RSHIFT_EXPR:
1842       opname = ">>"; break;
1843     case TRUNC_MOD_EXPR:
1844     case FLOOR_MOD_EXPR:
1845       opname = "%"; break;
1846     case TRUNC_DIV_EXPR:
1847     case FLOOR_DIV_EXPR:
1848       opname = "/"; break;
1849     case BIT_AND_EXPR:
1850       opname = "&"; break;
1851     case BIT_IOR_EXPR:
1852       opname = "|"; break;
1853     case TRUTH_ANDIF_EXPR:
1854       opname = "&&"; break;
1855     case TRUTH_ORIF_EXPR:
1856       opname = "||"; break;
1857     case BIT_XOR_EXPR:
1858       opname = "^"; break;
1859     case LROTATE_EXPR:
1860     case RROTATE_EXPR:
1861       opname = "rotate"; break;
1862     default:
1863       opname = "unknown"; break;
1864     }
1865   error ("invalid operands to binary %s", opname);
1866 }
1867 \f
1868 /* Subroutine of build_binary_op, used for comparison operations.
1869    See if the operands have both been converted from subword integer types
1870    and, if so, perhaps change them both back to their original type.
1871    This function is also responsible for converting the two operands
1872    to the proper common type for comparison.
1873
1874    The arguments of this function are all pointers to local variables
1875    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1876    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1877
1878    If this function returns nonzero, it means that the comparison has
1879    a constant value.  What this function returns is an expression for
1880    that value.  */
1881
1882 tree
1883 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
1884                  enum tree_code *rescode_ptr)
1885 {
1886   tree type;
1887   tree op0 = *op0_ptr;
1888   tree op1 = *op1_ptr;
1889   int unsignedp0, unsignedp1;
1890   int real1, real2;
1891   tree primop0, primop1;
1892   enum tree_code code = *rescode_ptr;
1893
1894   /* Throw away any conversions to wider types
1895      already present in the operands.  */
1896
1897   primop0 = get_narrower (op0, &unsignedp0);
1898   primop1 = get_narrower (op1, &unsignedp1);
1899
1900   /* Handle the case that OP0 does not *contain* a conversion
1901      but it *requires* conversion to FINAL_TYPE.  */
1902
1903   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1904     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1905   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1906     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1907
1908   /* If one of the operands must be floated, we cannot optimize.  */
1909   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1910   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1911
1912   /* If first arg is constant, swap the args (changing operation
1913      so value is preserved), for canonicalization.  Don't do this if
1914      the second arg is 0.  */
1915
1916   if (TREE_CONSTANT (primop0)
1917       && ! integer_zerop (primop1) && ! real_zerop (primop1))
1918     {
1919       tree tem = primop0;
1920       int temi = unsignedp0;
1921       primop0 = primop1;
1922       primop1 = tem;
1923       tem = op0;
1924       op0 = op1;
1925       op1 = tem;
1926       *op0_ptr = op0;
1927       *op1_ptr = op1;
1928       unsignedp0 = unsignedp1;
1929       unsignedp1 = temi;
1930       temi = real1;
1931       real1 = real2;
1932       real2 = temi;
1933
1934       switch (code)
1935         {
1936         case LT_EXPR:
1937           code = GT_EXPR;
1938           break;
1939         case GT_EXPR:
1940           code = LT_EXPR;
1941           break;
1942         case LE_EXPR:
1943           code = GE_EXPR;
1944           break;
1945         case GE_EXPR:
1946           code = LE_EXPR;
1947           break;
1948         default:
1949           break;
1950         }
1951       *rescode_ptr = code;
1952     }
1953
1954   /* If comparing an integer against a constant more bits wide,
1955      maybe we can deduce a value of 1 or 0 independent of the data.
1956      Or else truncate the constant now
1957      rather than extend the variable at run time.
1958
1959      This is only interesting if the constant is the wider arg.
1960      Also, it is not safe if the constant is unsigned and the
1961      variable arg is signed, since in this case the variable
1962      would be sign-extended and then regarded as unsigned.
1963      Our technique fails in this case because the lowest/highest
1964      possible unsigned results don't follow naturally from the
1965      lowest/highest possible values of the variable operand.
1966      For just EQ_EXPR and NE_EXPR there is another technique that
1967      could be used: see if the constant can be faithfully represented
1968      in the other operand's type, by truncating it and reextending it
1969      and see if that preserves the constant's value.  */
1970
1971   if (!real1 && !real2
1972       && TREE_CODE (primop1) == INTEGER_CST
1973       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1974     {
1975       int min_gt, max_gt, min_lt, max_lt;
1976       tree maxval, minval;
1977       /* 1 if comparison is nominally unsigned.  */
1978       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
1979       tree val;
1980
1981       type = c_common_signed_or_unsigned_type (unsignedp0,
1982                                                TREE_TYPE (primop0));
1983
1984       /* In C, if TYPE is an enumeration, then we need to get its
1985          min/max values from its underlying integral type, not the
1986          enumerated type itself.  In C++, TYPE_MAX_VALUE and
1987          TYPE_MIN_VALUE have already been set correctly on the
1988          enumeration type.  */
1989       if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
1990         type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
1991
1992       maxval = TYPE_MAX_VALUE (type);
1993       minval = TYPE_MIN_VALUE (type);
1994
1995       if (unsignedp && !unsignedp0)
1996         *restype_ptr = c_common_signed_type (*restype_ptr);
1997
1998       if (TREE_TYPE (primop1) != *restype_ptr)
1999         {
2000           tree tmp = convert (*restype_ptr, primop1);
2001           TREE_OVERFLOW (tmp) = TREE_OVERFLOW (primop1);
2002           TREE_CONSTANT_OVERFLOW (tmp) = TREE_CONSTANT_OVERFLOW (primop1);
2003           primop1 = tmp;
2004         }
2005       if (type != *restype_ptr)
2006         {
2007           minval = convert (*restype_ptr, minval);
2008           maxval = convert (*restype_ptr, maxval);
2009         }
2010
2011       if (unsignedp && unsignedp0)
2012         {
2013           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2014           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2015           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2016           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2017         }
2018       else
2019         {
2020           min_gt = INT_CST_LT (primop1, minval);
2021           max_gt = INT_CST_LT (primop1, maxval);
2022           min_lt = INT_CST_LT (minval, primop1);
2023           max_lt = INT_CST_LT (maxval, primop1);
2024         }
2025
2026       val = 0;
2027       /* This used to be a switch, but Genix compiler can't handle that.  */
2028       if (code == NE_EXPR)
2029         {
2030           if (max_lt || min_gt)
2031             val = truthvalue_true_node;
2032         }
2033       else if (code == EQ_EXPR)
2034         {
2035           if (max_lt || min_gt)
2036             val = truthvalue_false_node;
2037         }
2038       else if (code == LT_EXPR)
2039         {
2040           if (max_lt)
2041             val = truthvalue_true_node;
2042           if (!min_lt)
2043             val = truthvalue_false_node;
2044         }
2045       else if (code == GT_EXPR)
2046         {
2047           if (min_gt)
2048             val = truthvalue_true_node;
2049           if (!max_gt)
2050             val = truthvalue_false_node;
2051         }
2052       else if (code == LE_EXPR)
2053         {
2054           if (!max_gt)
2055             val = truthvalue_true_node;
2056           if (min_gt)
2057             val = truthvalue_false_node;
2058         }
2059       else if (code == GE_EXPR)
2060         {
2061           if (!min_lt)
2062             val = truthvalue_true_node;
2063           if (max_lt)
2064             val = truthvalue_false_node;
2065         }
2066
2067       /* If primop0 was sign-extended and unsigned comparison specd,
2068          we did a signed comparison above using the signed type bounds.
2069          But the comparison we output must be unsigned.
2070
2071          Also, for inequalities, VAL is no good; but if the signed
2072          comparison had *any* fixed result, it follows that the
2073          unsigned comparison just tests the sign in reverse
2074          (positive values are LE, negative ones GE).
2075          So we can generate an unsigned comparison
2076          against an extreme value of the signed type.  */
2077
2078       if (unsignedp && !unsignedp0)
2079         {
2080           if (val != 0)
2081             switch (code)
2082               {
2083               case LT_EXPR:
2084               case GE_EXPR:
2085                 primop1 = TYPE_MIN_VALUE (type);
2086                 val = 0;
2087                 break;
2088
2089               case LE_EXPR:
2090               case GT_EXPR:
2091                 primop1 = TYPE_MAX_VALUE (type);
2092                 val = 0;
2093                 break;
2094
2095               default:
2096                 break;
2097               }
2098           type = c_common_unsigned_type (type);
2099         }
2100
2101       if (TREE_CODE (primop0) != INTEGER_CST)
2102         {
2103           if (val == truthvalue_false_node)
2104             warning ("comparison is always false due to limited range of data type");
2105           if (val == truthvalue_true_node)
2106             warning ("comparison is always true due to limited range of data type");
2107         }
2108
2109       if (val != 0)
2110         {
2111           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2112           if (TREE_SIDE_EFFECTS (primop0))
2113             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2114           return val;
2115         }
2116
2117       /* Value is not predetermined, but do the comparison
2118          in the type of the operand that is not constant.
2119          TYPE is already properly set.  */
2120     }
2121   else if (real1 && real2
2122            && (TYPE_PRECISION (TREE_TYPE (primop0))
2123                == TYPE_PRECISION (TREE_TYPE (primop1))))
2124     type = TREE_TYPE (primop0);
2125
2126   /* If args' natural types are both narrower than nominal type
2127      and both extend in the same manner, compare them
2128      in the type of the wider arg.
2129      Otherwise must actually extend both to the nominal
2130      common type lest different ways of extending
2131      alter the result.
2132      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2133
2134   else if (unsignedp0 == unsignedp1 && real1 == real2
2135            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2136            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2137     {
2138       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2139       type = c_common_signed_or_unsigned_type (unsignedp0
2140                                                || TYPE_UNSIGNED (*restype_ptr),
2141                                                type);
2142       /* Make sure shorter operand is extended the right way
2143          to match the longer operand.  */
2144       primop0
2145         = convert (c_common_signed_or_unsigned_type (unsignedp0,
2146                                                      TREE_TYPE (primop0)),
2147                    primop0);
2148       primop1
2149         = convert (c_common_signed_or_unsigned_type (unsignedp1,
2150                                                      TREE_TYPE (primop1)),
2151                    primop1);
2152     }
2153   else
2154     {
2155       /* Here we must do the comparison on the nominal type
2156          using the args exactly as we received them.  */
2157       type = *restype_ptr;
2158       primop0 = op0;
2159       primop1 = op1;
2160
2161       if (!real1 && !real2 && integer_zerop (primop1)
2162           && TYPE_UNSIGNED (*restype_ptr))
2163         {
2164           tree value = 0;
2165           switch (code)
2166             {
2167             case GE_EXPR:
2168               /* All unsigned values are >= 0, so we warn if extra warnings
2169                  are requested.  However, if OP0 is a constant that is
2170                  >= 0, the signedness of the comparison isn't an issue,
2171                  so suppress the warning.  */
2172               if (extra_warnings && !in_system_header
2173                   && ! (TREE_CODE (primop0) == INTEGER_CST
2174                         && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2175                                                      primop0))))
2176                 warning ("comparison of unsigned expression >= 0 is always true");
2177               value = truthvalue_true_node;
2178               break;
2179
2180             case LT_EXPR:
2181               if (extra_warnings && !in_system_header
2182                   && ! (TREE_CODE (primop0) == INTEGER_CST
2183                         && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2184                                                      primop0))))
2185                 warning ("comparison of unsigned expression < 0 is always false");
2186               value = truthvalue_false_node;
2187               break;
2188
2189             default:
2190               break;
2191             }
2192
2193           if (value != 0)
2194             {
2195               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2196               if (TREE_SIDE_EFFECTS (primop0))
2197                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2198                               primop0, value);
2199               return value;
2200             }
2201         }
2202     }
2203
2204   *op0_ptr = convert (type, primop0);
2205   *op1_ptr = convert (type, primop1);
2206
2207   *restype_ptr = truthvalue_type_node;
2208
2209   return 0;
2210 }
2211 \f
2212 /* Return a tree for the sum or difference (RESULTCODE says which)
2213    of pointer PTROP and integer INTOP.  */
2214
2215 tree
2216 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2217 {
2218   tree size_exp;
2219
2220   /* The result is a pointer of the same type that is being added.  */
2221
2222   tree result_type = TREE_TYPE (ptrop);
2223
2224   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2225     {
2226       if (pedantic || warn_pointer_arith)
2227         pedwarn ("pointer of type `void *' used in arithmetic");
2228       size_exp = integer_one_node;
2229     }
2230   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2231     {
2232       if (pedantic || warn_pointer_arith)
2233         pedwarn ("pointer to a function used in arithmetic");
2234       size_exp = integer_one_node;
2235     }
2236   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2237     {
2238       if (pedantic || warn_pointer_arith)
2239         pedwarn ("pointer to member function used in arithmetic");
2240       size_exp = integer_one_node;
2241     }
2242   else
2243     size_exp = size_in_bytes (TREE_TYPE (result_type));
2244
2245   /* If what we are about to multiply by the size of the elements
2246      contains a constant term, apply distributive law
2247      and multiply that constant term separately.
2248      This helps produce common subexpressions.  */
2249
2250   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2251       && ! TREE_CONSTANT (intop)
2252       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2253       && TREE_CONSTANT (size_exp)
2254       /* If the constant comes from pointer subtraction,
2255          skip this optimization--it would cause an error.  */
2256       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2257       /* If the constant is unsigned, and smaller than the pointer size,
2258          then we must skip this optimization.  This is because it could cause
2259          an overflow error if the constant is negative but INTOP is not.  */
2260       && (! TYPE_UNSIGNED (TREE_TYPE (intop))
2261           || (TYPE_PRECISION (TREE_TYPE (intop))
2262               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2263     {
2264       enum tree_code subcode = resultcode;
2265       tree int_type = TREE_TYPE (intop);
2266       if (TREE_CODE (intop) == MINUS_EXPR)
2267         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2268       /* Convert both subexpression types to the type of intop,
2269          because weird cases involving pointer arithmetic
2270          can result in a sum or difference with different type args.  */
2271       ptrop = build_binary_op (subcode, ptrop,
2272                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2273       intop = convert (int_type, TREE_OPERAND (intop, 0));
2274     }
2275
2276   /* Convert the integer argument to a type the same size as sizetype
2277      so the multiply won't overflow spuriously.  */
2278
2279   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2280       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2281     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2282                                              TYPE_UNSIGNED (sizetype)), intop);
2283
2284   /* Replace the integer argument with a suitable product by the object size.
2285      Do this multiplication as signed, then convert to the appropriate
2286      pointer type (actually unsigned integral).  */
2287
2288   intop = convert (result_type,
2289                    build_binary_op (MULT_EXPR, intop,
2290                                     convert (TREE_TYPE (intop), size_exp), 1));
2291
2292   /* Create the sum or difference.  */
2293   return fold (build (resultcode, result_type, ptrop, intop));
2294 }
2295 \f
2296 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2297    or validate its data type for an `if' or `while' statement or ?..: exp.
2298
2299    This preparation consists of taking the ordinary
2300    representation of an expression expr and producing a valid tree
2301    boolean expression describing whether expr is nonzero.  We could
2302    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2303    but we optimize comparisons, &&, ||, and !.
2304
2305    The resulting type should always be `truthvalue_type_node'.  */
2306
2307 tree
2308 c_common_truthvalue_conversion (tree expr)
2309 {
2310   if (TREE_CODE (expr) == ERROR_MARK)
2311     return expr;
2312
2313   if (TREE_CODE (expr) == FUNCTION_DECL)
2314     expr = build_unary_op (ADDR_EXPR, expr, 0);
2315
2316   switch (TREE_CODE (expr))
2317     {
2318     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
2319     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
2320     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2321     case ORDERED_EXPR: case UNORDERED_EXPR:
2322     case TRUTH_ANDIF_EXPR:
2323     case TRUTH_ORIF_EXPR:
2324     case TRUTH_AND_EXPR:
2325     case TRUTH_OR_EXPR:
2326     case TRUTH_XOR_EXPR:
2327     case TRUTH_NOT_EXPR:
2328       TREE_TYPE (expr) = truthvalue_type_node;
2329       return expr;
2330
2331     case ERROR_MARK:
2332       return expr;
2333
2334     case INTEGER_CST:
2335       return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2336
2337     case REAL_CST:
2338       return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2339
2340     case ADDR_EXPR:
2341       {
2342         if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2343             && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2344           {
2345             /* Common Ada/Pascal programmer's mistake.  We always warn
2346                about this since it is so bad.  */
2347             warning ("the address of `%D', will always evaluate as `true'",
2348                      TREE_OPERAND (expr, 0));
2349             return truthvalue_true_node;
2350           }
2351
2352         /* If we are taking the address of an external decl, it might be
2353            zero if it is weak, so we cannot optimize.  */
2354         if (DECL_P (TREE_OPERAND (expr, 0))
2355             && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2356           break;
2357
2358         if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2359           return build (COMPOUND_EXPR, truthvalue_type_node,
2360                         TREE_OPERAND (expr, 0), truthvalue_true_node);
2361         else
2362           return truthvalue_true_node;
2363       }
2364
2365     case COMPLEX_EXPR:
2366       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2367                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2368                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
2369                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2370                               0);
2371
2372     case NEGATE_EXPR:
2373     case ABS_EXPR:
2374     case FLOAT_EXPR:
2375       /* These don't change whether an object is nonzero or zero.  */
2376       return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2377
2378     case LROTATE_EXPR:
2379     case RROTATE_EXPR:
2380       /* These don't change whether an object is zero or nonzero, but
2381          we can't ignore them if their second arg has side-effects.  */
2382       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2383         return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2384                       lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
2385       else
2386         return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2387
2388     case COND_EXPR:
2389       /* Distribute the conversion into the arms of a COND_EXPR.  */
2390       return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2391                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2392                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2))));
2393
2394     case CONVERT_EXPR:
2395       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2396          since that affects how `default_conversion' will behave.  */
2397       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2398           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2399         break;
2400       /* Fall through....  */
2401     case NOP_EXPR:
2402       /* If this is widening the argument, we can ignore it.  */
2403       if (TYPE_PRECISION (TREE_TYPE (expr))
2404           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2405         return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2406       break;
2407
2408     case MINUS_EXPR:
2409       /* Perhaps reduce (x - y) != 0 to (x != y).  The expressions
2410          aren't guaranteed to the be same for modes that can represent
2411          infinity, since if x and y are both +infinity, or both
2412          -infinity, then x - y is not a number.
2413
2414          Note that this transformation is safe when x or y is NaN.
2415          (x - y) is then NaN, and both (x - y) != 0 and x != y will
2416          be false.  */
2417       if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2418         break;
2419       /* Fall through....  */
2420     case BIT_XOR_EXPR:
2421       /* This and MINUS_EXPR can be changed into a comparison of the
2422          two objects.  */
2423       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2424           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2425         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2426                                 TREE_OPERAND (expr, 1), 1);
2427       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2428                               fold (build1 (NOP_EXPR,
2429                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2430                                             TREE_OPERAND (expr, 1))), 1);
2431
2432     case BIT_AND_EXPR:
2433       if (integer_onep (TREE_OPERAND (expr, 1))
2434           && TREE_TYPE (expr) != truthvalue_type_node)
2435         /* Using convert here would cause infinite recursion.  */
2436         return build1 (NOP_EXPR, truthvalue_type_node, expr);
2437       break;
2438
2439     case MODIFY_EXPR:
2440       if (warn_parentheses && !TREE_NO_WARNING (expr))
2441         warning ("suggest parentheses around assignment used as truth value");
2442       break;
2443
2444     default:
2445       break;
2446     }
2447
2448   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2449     {
2450       tree t = save_expr (expr);
2451       return (build_binary_op
2452               ((TREE_SIDE_EFFECTS (expr)
2453                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2454         lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2455         lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2456                0));
2457     }
2458
2459   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2460 }
2461 \f
2462 static tree builtin_function_2 (const char *builtin_name, const char *name,
2463                                 tree builtin_type, tree type,
2464                                 enum built_in_function function_code,
2465                                 enum built_in_class cl, int library_name_p,
2466                                 bool nonansi_p,
2467                                 tree attrs);
2468
2469 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2470    down to the element type of an array.  */
2471
2472 tree
2473 c_build_qualified_type (tree type, int type_quals)
2474 {
2475   if (type == error_mark_node)
2476     return type;
2477
2478   if (TREE_CODE (type) == ARRAY_TYPE)
2479     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2480                                                      type_quals),
2481                              TYPE_DOMAIN (type));
2482
2483   /* A restrict-qualified pointer type must be a pointer to object or
2484      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2485      REFERENCE_TYPEs, which is appropriate for C++.  */
2486   if ((type_quals & TYPE_QUAL_RESTRICT)
2487       && (!POINTER_TYPE_P (type)
2488           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2489     {
2490       error ("invalid use of `restrict'");
2491       type_quals &= ~TYPE_QUAL_RESTRICT;
2492     }
2493
2494   return build_qualified_type (type, type_quals);
2495 }
2496
2497 /* Apply the TYPE_QUALS to the new DECL.  */
2498
2499 void
2500 c_apply_type_quals_to_decl (int type_quals, tree decl)
2501 {
2502   tree type = TREE_TYPE (decl);
2503
2504   if (type == error_mark_node)
2505     return;
2506
2507   if (((type_quals & TYPE_QUAL_CONST)
2508        || (type && TREE_CODE (type) == REFERENCE_TYPE))
2509       /* An object declared 'const' is only readonly after it is
2510          initialized.  We don't have any way of expressing this currently,
2511          so we need to be conservative and unset TREE_READONLY for types
2512          with constructors.  Otherwise aliasing code will ignore stores in
2513          an inline constructor.  */
2514       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2515     TREE_READONLY (decl) = 1;
2516   if (type_quals & TYPE_QUAL_VOLATILE)
2517     {
2518       TREE_SIDE_EFFECTS (decl) = 1;
2519       TREE_THIS_VOLATILE (decl) = 1;
2520     }
2521   if (type_quals & TYPE_QUAL_RESTRICT)
2522     {
2523       while (type && TREE_CODE (type) == ARRAY_TYPE)
2524         /* Allow 'restrict' on arrays of pointers.
2525            FIXME currently we just ignore it.  */
2526         type = TREE_TYPE (type);
2527       if (!type
2528           || !POINTER_TYPE_P (type)
2529           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2530         error ("invalid use of `restrict'");
2531       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2532         /* Indicate we need to make a unique alias set for this pointer.
2533            We can't do it here because it might be pointing to an
2534            incomplete type.  */
2535         DECL_POINTER_ALIAS_SET (decl) = -2;
2536     }
2537 }
2538
2539 /* Hash function for the problem of multiple type definitions in
2540    different files.  This must hash all types that will compare
2541    equal via comptypes to the same value.  In practice it hashes
2542    on some of the simple stuff and leaves the details to comptypes.  */
2543
2544 static hashval_t
2545 c_type_hash (const void *p)
2546 {
2547   int i = 0;
2548   int shift, size;
2549   tree t = (tree)p;
2550   tree t2;
2551   switch (TREE_CODE (t))
2552     {
2553     /* For pointers, hash on pointee type plus some swizzling. */
2554     case POINTER_TYPE:
2555       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2556     /* Hash on number of elements and total size.  */
2557     case ENUMERAL_TYPE:
2558       shift = 3;
2559       t2 = TYPE_VALUES (t);
2560       break;
2561     case RECORD_TYPE:
2562       shift = 0;
2563       t2 = TYPE_FIELDS (t);
2564       break;
2565     case QUAL_UNION_TYPE:
2566       shift = 1;
2567       t2 = TYPE_FIELDS (t);
2568       break;
2569     case UNION_TYPE:
2570       shift = 2;
2571       t2 = TYPE_FIELDS (t);
2572       break;
2573     default:
2574       abort ();
2575     }
2576   for (; t2; t2 = TREE_CHAIN (t2))
2577     i++;
2578   size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2579   return ((size << 24) | (i << shift));
2580 }
2581
2582 /* Return the typed-based alias set for T, which may be an expression
2583    or a type.  Return -1 if we don't do anything special.  */
2584
2585 HOST_WIDE_INT
2586 c_common_get_alias_set (tree t)
2587 {
2588   tree u;
2589   PTR *slot;
2590   static htab_t type_hash_table;
2591
2592   /* Permit type-punning when accessing a union, provided the access
2593      is directly through the union.  For example, this code does not
2594      permit taking the address of a union member and then storing
2595      through it.  Even the type-punning allowed here is a GCC
2596      extension, albeit a common and useful one; the C standard says
2597      that such accesses have implementation-defined behavior.  */
2598   for (u = t;
2599        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2600        u = TREE_OPERAND (u, 0))
2601     if (TREE_CODE (u) == COMPONENT_REF
2602         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2603       return 0;
2604
2605   /* That's all the expressions we handle specially.  */
2606   if (! TYPE_P (t))
2607     return -1;
2608
2609   /* The C standard guarantees that any object may be accessed via an
2610      lvalue that has character type.  */
2611   if (t == char_type_node
2612       || t == signed_char_type_node
2613       || t == unsigned_char_type_node)
2614     return 0;
2615
2616   /* If it has the may_alias attribute, it can alias anything.  */
2617   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2618     return 0;
2619
2620   /* The C standard specifically allows aliasing between signed and
2621      unsigned variants of the same type.  We treat the signed
2622      variant as canonical.  */
2623   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2624     {
2625       tree t1 = c_common_signed_type (t);
2626
2627       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2628       if (t1 != t)
2629         return get_alias_set (t1);
2630     }
2631   else if (POINTER_TYPE_P (t))
2632     {
2633       tree t1;
2634
2635       /* Unfortunately, there is no canonical form of a pointer type.
2636          In particular, if we have `typedef int I', then `int *', and
2637          `I *' are different types.  So, we have to pick a canonical
2638          representative.  We do this below.
2639
2640          Technically, this approach is actually more conservative that
2641          it needs to be.  In particular, `const int *' and `int *'
2642          should be in different alias sets, according to the C and C++
2643          standard, since their types are not the same, and so,
2644          technically, an `int **' and `const int **' cannot point at
2645          the same thing.
2646
2647          But, the standard is wrong.  In particular, this code is
2648          legal C++:
2649
2650             int *ip;
2651             int **ipp = &ip;
2652             const int* const* cipp = ipp;
2653
2654          And, it doesn't make sense for that to be legal unless you
2655          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2656          the pointed-to types.  This issue has been reported to the
2657          C++ committee.  */
2658       t1 = build_type_no_quals (t);
2659       if (t1 != t)
2660         return get_alias_set (t1);
2661     }
2662
2663   /* Handle the case of multiple type nodes referring to "the same" type,
2664      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
2665      C90 is handled.  (In C99 type compatibility is not transitive, which
2666      complicates things mightily. The alias set splay trees can theoretically
2667      represent this, but insertion is tricky when you consider all the
2668      different orders things might arrive in.) */
2669
2670   if (c_language != clk_c || flag_isoc99)
2671     return -1;
2672
2673   /* Save time if there's only one input file.  */
2674   if (num_in_fnames == 1)
2675     return -1;
2676
2677   /* Pointers need special handling if they point to any type that
2678      needs special handling (below).  */
2679   if (TREE_CODE (t) == POINTER_TYPE)
2680     {
2681       tree t2;
2682       /* Find bottom type under any nested POINTERs.  */
2683       for (t2 = TREE_TYPE (t);
2684      TREE_CODE (t2) == POINTER_TYPE;
2685      t2 = TREE_TYPE (t2))
2686   ;
2687       if (TREE_CODE (t2) != RECORD_TYPE
2688     && TREE_CODE (t2) != ENUMERAL_TYPE
2689     && TREE_CODE (t2) != QUAL_UNION_TYPE
2690     && TREE_CODE (t2) != UNION_TYPE)
2691   return -1;
2692       if (TYPE_SIZE (t2) == 0)
2693   return -1;
2694     }
2695   /* These are the only cases that need special handling.  */
2696   if (TREE_CODE (t) != RECORD_TYPE
2697       && TREE_CODE (t) != ENUMERAL_TYPE
2698       && TREE_CODE (t) != QUAL_UNION_TYPE
2699       && TREE_CODE (t) != UNION_TYPE
2700       && TREE_CODE (t) != POINTER_TYPE)
2701     return -1;
2702   /* Undefined? */
2703   if (TYPE_SIZE (t) == 0)
2704     return -1;
2705
2706   /* Look up t in hash table.  Only one of the compatible types within each
2707      alias set is recorded in the table.  */
2708   if (!type_hash_table)
2709     type_hash_table = htab_create (1021, c_type_hash,
2710             (htab_eq) lang_hooks.types_compatible_p,
2711             NULL);
2712   slot = htab_find_slot (type_hash_table, t, INSERT);
2713   if (*slot != NULL)
2714     return TYPE_ALIAS_SET ((tree)*slot);
2715   else
2716     /* Our caller will assign and record (in t) a new alias set; all we need
2717        to do is remember t in the hash table.  */
2718     *slot = t;
2719
2720   return -1;
2721 }
2722 \f
2723 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2724    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
2725    flag controls whether we should diagnose possibly ill-formed
2726    constructs or not.  */
2727 tree
2728 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2729 {
2730   const char *op_name;
2731   tree value = NULL;
2732   enum tree_code type_code = TREE_CODE (type);
2733
2734   my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2735   op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2736
2737   if (type_code == FUNCTION_TYPE)
2738     {
2739       if (op == SIZEOF_EXPR)
2740         {
2741           if (complain && (pedantic || warn_pointer_arith))
2742             pedwarn ("invalid application of `sizeof' to a function type");
2743           value = size_one_node;
2744         }
2745       else
2746         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2747     }
2748   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2749     {
2750       if (type_code == VOID_TYPE
2751           && complain && (pedantic || warn_pointer_arith))
2752         pedwarn ("invalid application of `%s' to a void type", op_name);
2753       value = size_one_node;
2754     }
2755   else if (!COMPLETE_TYPE_P (type))
2756     {
2757       if (complain)
2758         error ("invalid application of `%s' to incomplete type `%T' ",
2759                op_name, type);
2760       value = size_zero_node;
2761     }
2762   else
2763     {
2764       if (op == (enum tree_code) SIZEOF_EXPR)
2765         /* Convert in case a char is more than one unit.  */
2766         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2767                             size_int (TYPE_PRECISION (char_type_node)
2768                                       / BITS_PER_UNIT));
2769       else
2770         value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2771     }
2772
2773   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2774      TYPE_IS_SIZETYPE means that certain things (like overflow) will
2775      never happen.  However, this node should really have type
2776      `size_t', which is just a typedef for an ordinary integer type.  */
2777   value = fold (build1 (NOP_EXPR, size_type_node, value));
2778   my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2779
2780   return value;
2781 }
2782
2783 /* Implement the __alignof keyword: Return the minimum required
2784    alignment of EXPR, measured in bytes.  For VAR_DECL's and
2785    FIELD_DECL's return DECL_ALIGN (which can be set from an
2786    "aligned" __attribute__ specification).  */
2787
2788 tree
2789 c_alignof_expr (tree expr)
2790 {
2791   tree t;
2792
2793   if (TREE_CODE (expr) == VAR_DECL)
2794     t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2795
2796   else if (TREE_CODE (expr) == COMPONENT_REF
2797            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2798     {
2799       error ("`__alignof' applied to a bit-field");
2800       t = size_one_node;
2801     }
2802   else if (TREE_CODE (expr) == COMPONENT_REF
2803            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2804     t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2805
2806   else if (TREE_CODE (expr) == INDIRECT_REF)
2807     {
2808       tree t = TREE_OPERAND (expr, 0);
2809       tree best = t;
2810       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2811
2812       while (TREE_CODE (t) == NOP_EXPR
2813              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2814         {
2815           int thisalign;
2816
2817           t = TREE_OPERAND (t, 0);
2818           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2819           if (thisalign > bestalign)
2820             best = t, bestalign = thisalign;
2821         }
2822       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2823     }
2824   else
2825     return c_alignof (TREE_TYPE (expr));
2826
2827   return fold (build1 (NOP_EXPR, size_type_node, t));
2828 }
2829 \f
2830 /* Handle C and C++ default attributes.  */
2831
2832 enum built_in_attribute
2833 {
2834 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2835 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2836 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2837 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2838 #include "builtin-attrs.def"
2839 #undef DEF_ATTR_NULL_TREE
2840 #undef DEF_ATTR_INT
2841 #undef DEF_ATTR_IDENT
2842 #undef DEF_ATTR_TREE_LIST
2843   ATTR_LAST
2844 };
2845
2846 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2847
2848 static void c_init_attributes (void);
2849
2850 /* Build tree nodes and builtin functions common to both C and C++ language
2851    frontends.  */
2852
2853 void
2854 c_common_nodes_and_builtins (void)
2855 {
2856   enum builtin_type
2857   {
2858 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2859 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2860 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2861 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2862 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2863 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2864 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2865 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2866 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2867 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2868 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2869 #include "builtin-types.def"
2870 #undef DEF_PRIMITIVE_TYPE
2871 #undef DEF_FUNCTION_TYPE_0
2872 #undef DEF_FUNCTION_TYPE_1
2873 #undef DEF_FUNCTION_TYPE_2
2874 #undef DEF_FUNCTION_TYPE_3
2875 #undef DEF_FUNCTION_TYPE_4
2876 #undef DEF_FUNCTION_TYPE_VAR_0
2877 #undef DEF_FUNCTION_TYPE_VAR_1
2878 #undef DEF_FUNCTION_TYPE_VAR_2
2879 #undef DEF_FUNCTION_TYPE_VAR_3
2880 #undef DEF_POINTER_TYPE
2881     BT_LAST
2882   };
2883
2884   typedef enum builtin_type builtin_type;
2885
2886   tree builtin_types[(int) BT_LAST];
2887   int wchar_type_size;
2888   tree array_domain_type;
2889   tree va_list_ref_type_node;
2890   tree va_list_arg_type_node;
2891
2892   /* Define `int' and `char' first so that dbx will output them first.  */
2893   record_builtin_type (RID_INT, NULL, integer_type_node);
2894   record_builtin_type (RID_CHAR, "char", char_type_node);
2895
2896   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
2897      "unsigned long", "long long unsigned" and "unsigned short" were in C++
2898      but not C.  Are the conditionals here needed?  */
2899   if (c_dialect_cxx ())
2900     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2901   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2902   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2903   record_builtin_type (RID_MAX, "long unsigned int",
2904                        long_unsigned_type_node);
2905   if (c_dialect_cxx ())
2906     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2907   record_builtin_type (RID_MAX, "long long int",
2908                        long_long_integer_type_node);
2909   record_builtin_type (RID_MAX, "long long unsigned int",
2910                        long_long_unsigned_type_node);
2911   if (c_dialect_cxx ())
2912     record_builtin_type (RID_MAX, "long long unsigned",
2913                          long_long_unsigned_type_node);
2914   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2915   record_builtin_type (RID_MAX, "short unsigned int",
2916                        short_unsigned_type_node);
2917   if (c_dialect_cxx ())
2918     record_builtin_type (RID_MAX, "unsigned short",
2919                          short_unsigned_type_node);
2920
2921   /* Define both `signed char' and `unsigned char'.  */
2922   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2923   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2924
2925   /* These are types that c_common_type_for_size and
2926      c_common_type_for_mode use.  */
2927   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2928                                          intQI_type_node));
2929   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2930                                          intHI_type_node));
2931   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2932                                          intSI_type_node));
2933   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2934                                          intDI_type_node));
2935 #if HOST_BITS_PER_WIDE_INT >= 64
2936   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2937                                          get_identifier ("__int128_t"),
2938                                          intTI_type_node));
2939 #endif
2940   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2941                                          unsigned_intQI_type_node));
2942   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2943                                          unsigned_intHI_type_node));
2944   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2945                                          unsigned_intSI_type_node));
2946   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2947                                          unsigned_intDI_type_node));
2948 #if HOST_BITS_PER_WIDE_INT >= 64
2949   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2950                                          get_identifier ("__uint128_t"),
2951                                          unsigned_intTI_type_node));
2952 #endif
2953
2954   /* Create the widest literal types.  */
2955   widest_integer_literal_type_node
2956     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2957   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2958                                          widest_integer_literal_type_node));
2959
2960   widest_unsigned_literal_type_node
2961     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2962   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2963                                          widest_unsigned_literal_type_node));
2964
2965   /* `unsigned long' is the standard type for sizeof.
2966      Note that stddef.h uses `unsigned long',
2967      and this must agree, even if long and int are the same size.  */
2968   size_type_node =
2969     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2970   signed_size_type_node = c_common_signed_type (size_type_node);
2971   set_sizetype (size_type_node);
2972
2973   pid_type_node =
2974     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
2975
2976   build_common_tree_nodes_2 (flag_short_double);
2977
2978   record_builtin_type (RID_FLOAT, NULL, float_type_node);
2979   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2980   record_builtin_type (RID_MAX, "long double", long_double_type_node);
2981
2982   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2983                                          get_identifier ("complex int"),
2984                                          complex_integer_type_node));
2985   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2986                                          get_identifier ("complex float"),
2987                                          complex_float_type_node));
2988   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2989                                          get_identifier ("complex double"),
2990                                          complex_double_type_node));
2991   lang_hooks.decls.pushdecl
2992     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2993                  complex_long_double_type_node));
2994
2995   if (c_dialect_cxx ())
2996     /* For C++, make fileptr_type_node a distinct void * type until
2997        FILE type is defined.  */
2998     fileptr_type_node = build_type_copy (ptr_type_node);
2999
3000   record_builtin_type (RID_VOID, NULL, void_type_node);
3001
3002   void_zero_node = build_int_2 (0, 0);
3003   TREE_TYPE (void_zero_node) = void_type_node;
3004
3005   void_list_node = build_void_list_node ();
3006
3007   /* Make a type to be the domain of a few array types
3008      whose domains don't really matter.
3009      200 is small enough that it always fits in size_t
3010      and large enough that it can hold most function names for the
3011      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3012   array_domain_type = build_index_type (size_int (200));
3013
3014   /* Make a type for arrays of characters.
3015      With luck nothing will ever really depend on the length of this
3016      array type.  */
3017   char_array_type_node
3018     = build_array_type (char_type_node, array_domain_type);
3019
3020   /* Likewise for arrays of ints.  */
3021   int_array_type_node
3022     = build_array_type (integer_type_node, array_domain_type);
3023
3024   string_type_node = build_pointer_type (char_type_node);
3025   const_string_type_node
3026     = build_pointer_type (build_qualified_type
3027                           (char_type_node, TYPE_QUAL_CONST));
3028
3029   /* This is special for C++ so functions can be overloaded.  */
3030   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3031   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3032   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3033   if (c_dialect_cxx ())
3034     {
3035       if (TYPE_UNSIGNED (wchar_type_node))
3036         wchar_type_node = make_unsigned_type (wchar_type_size);
3037       else
3038         wchar_type_node = make_signed_type (wchar_type_size);
3039       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3040     }
3041   else
3042     {
3043       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3044       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3045     }
3046
3047   /* This is for wide string constants.  */
3048   wchar_array_type_node
3049     = build_array_type (wchar_type_node, array_domain_type);
3050
3051   wint_type_node =
3052     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3053
3054   intmax_type_node =
3055     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3056   uintmax_type_node =
3057     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3058
3059   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3060   ptrdiff_type_node
3061     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3062   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3063
3064   lang_hooks.decls.pushdecl
3065     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3066                  va_list_type_node));
3067
3068   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3069     {
3070       va_list_arg_type_node = va_list_ref_type_node =
3071         build_pointer_type (TREE_TYPE (va_list_type_node));
3072     }
3073   else
3074     {
3075       va_list_arg_type_node = va_list_type_node;
3076       va_list_ref_type_node = build_reference_type (va_list_type_node);
3077     }
3078
3079 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3080   builtin_types[(int) ENUM] = VALUE;
3081 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
3082   builtin_types[(int) ENUM]                             \
3083     = build_function_type (builtin_types[(int) RETURN], \
3084                            void_list_node);
3085 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
3086   builtin_types[(int) ENUM]                                             \
3087     = build_function_type (builtin_types[(int) RETURN],                 \
3088                            tree_cons (NULL_TREE,                        \
3089                                       builtin_types[(int) ARG1],        \
3090                                       void_list_node));
3091 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
3092   builtin_types[(int) ENUM]                             \
3093     = build_function_type                               \
3094       (builtin_types[(int) RETURN],                     \
3095        tree_cons (NULL_TREE,                            \
3096                   builtin_types[(int) ARG1],            \
3097                   tree_cons (NULL_TREE,                 \
3098                              builtin_types[(int) ARG2], \
3099                              void_list_node)));
3100 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
3101   builtin_types[(int) ENUM]                                              \
3102     = build_function_type                                                \
3103       (builtin_types[(int) RETURN],                                      \
3104        tree_cons (NULL_TREE,                                             \
3105                   builtin_types[(int) ARG1],                             \
3106                   tree_cons (NULL_TREE,                                  \
3107                              builtin_types[(int) ARG2],                  \
3108                              tree_cons (NULL_TREE,                       \
3109                                         builtin_types[(int) ARG3],       \
3110                                         void_list_node))));
3111 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
3112   builtin_types[(int) ENUM]                                             \
3113     = build_function_type                                               \
3114       (builtin_types[(int) RETURN],                                     \
3115        tree_cons (NULL_TREE,                                            \
3116                   builtin_types[(int) ARG1],                            \
3117                   tree_cons (NULL_TREE,                                 \
3118                              builtin_types[(int) ARG2],                 \
3119                              tree_cons                                  \
3120                              (NULL_TREE,                                \
3121                               builtin_types[(int) ARG3],                \
3122                               tree_cons (NULL_TREE,                     \
3123                                          builtin_types[(int) ARG4],     \
3124                                          void_list_node)))));
3125 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
3126   builtin_types[(int) ENUM]                                             \
3127     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3128 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
3129    builtin_types[(int) ENUM]                                             \
3130     = build_function_type (builtin_types[(int) RETURN],          \
3131                            tree_cons (NULL_TREE,                         \
3132                                       builtin_types[(int) ARG1],         \
3133                                       NULL_TREE));
3134
3135 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
3136    builtin_types[(int) ENUM]                                    \
3137     = build_function_type                                       \
3138       (builtin_types[(int) RETURN],                             \
3139        tree_cons (NULL_TREE,                                    \
3140                   builtin_types[(int) ARG1],                    \
3141                   tree_cons (NULL_TREE,                         \
3142                              builtin_types[(int) ARG2],         \
3143                              NULL_TREE)));
3144
3145 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3)         \
3146    builtin_types[(int) ENUM]                                            \
3147     = build_function_type                                               \
3148       (builtin_types[(int) RETURN],                                     \
3149        tree_cons (NULL_TREE,                                            \
3150                   builtin_types[(int) ARG1],                            \
3151                   tree_cons (NULL_TREE,                                 \
3152                              builtin_types[(int) ARG2],                 \
3153                              tree_cons (NULL_TREE,                      \
3154                                         builtin_types[(int) ARG3],      \
3155                                         NULL_TREE))));
3156
3157 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
3158   builtin_types[(int) ENUM]                             \
3159     = build_pointer_type (builtin_types[(int) TYPE]);
3160 #include "builtin-types.def"
3161 #undef DEF_PRIMITIVE_TYPE
3162 #undef DEF_FUNCTION_TYPE_1
3163 #undef DEF_FUNCTION_TYPE_2
3164 #undef DEF_FUNCTION_TYPE_3
3165 #undef DEF_FUNCTION_TYPE_4
3166 #undef DEF_FUNCTION_TYPE_VAR_0
3167 #undef DEF_FUNCTION_TYPE_VAR_1
3168 #undef DEF_FUNCTION_TYPE_VAR_2
3169 #undef DEF_FUNCTION_TYPE_VAR_3
3170 #undef DEF_POINTER_TYPE
3171
3172   c_init_attributes ();
3173
3174 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE,                   \
3175                     BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT)     \
3176   if (NAME)                                                             \
3177     {                                                                   \
3178       tree decl;                                                        \
3179                                                                         \
3180       if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0)     \
3181         abort ();                                                       \
3182                                                                         \
3183       if (!BOTH_P)                                                      \
3184         decl = lang_hooks.builtin_function (NAME, builtin_types[TYPE],  \
3185                                  ENUM,                                  \
3186                                  CLASS,                                 \
3187                                  (FALLBACK_P                            \
3188                                   ? (NAME + strlen ("__builtin_"))      \
3189                                   : NULL),                              \
3190                                  built_in_attributes[(int) ATTRS]);     \
3191       else                                                              \
3192         decl = builtin_function_2 (NAME,                                \
3193                                    NAME + strlen ("__builtin_"),        \
3194                                    builtin_types[TYPE],                 \
3195                                    builtin_types[LIBTYPE],              \
3196                                    ENUM,                                \
3197                                    CLASS,                               \
3198                                    FALLBACK_P,                          \
3199                                    NONANSI_P,                           \
3200                                    built_in_attributes[(int) ATTRS]);   \
3201                                                                         \
3202       built_in_decls[(int) ENUM] = decl;                                \
3203       if (IMPLICIT)                                                     \
3204         implicit_built_in_decls[(int) ENUM] = decl;                     \
3205     }
3206 #include "builtins.def"
3207 #undef DEF_BUILTIN
3208
3209   targetm.init_builtins ();
3210   if (flag_mudflap)
3211     mudflap_init ();
3212
3213   main_identifier_node = get_identifier ("main");
3214 }
3215
3216 tree
3217 build_va_arg (tree expr, tree type)
3218 {
3219   return build1 (VA_ARG_EXPR, type, expr);
3220 }
3221
3222
3223 /* Linked list of disabled built-in functions.  */
3224
3225 typedef struct disabled_builtin
3226 {
3227   const char *name;
3228   struct disabled_builtin *next;
3229 } disabled_builtin;
3230 static disabled_builtin *disabled_builtins = NULL;
3231
3232 static bool builtin_function_disabled_p (const char *);
3233
3234 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
3235    begins with "__builtin_", give an error.  */
3236
3237 void
3238 disable_builtin_function (const char *name)
3239 {
3240   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3241     error ("cannot disable built-in function `%s'", name);
3242   else
3243     {
3244       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3245       new_disabled_builtin->name = name;
3246       new_disabled_builtin->next = disabled_builtins;
3247       disabled_builtins = new_disabled_builtin;
3248     }
3249 }
3250
3251
3252 /* Return true if the built-in function NAME has been disabled, false
3253    otherwise.  */
3254
3255 static bool
3256 builtin_function_disabled_p (const char *name)
3257 {
3258   disabled_builtin *p;
3259   for (p = disabled_builtins; p != NULL; p = p->next)
3260     {
3261       if (strcmp (name, p->name) == 0)
3262         return true;
3263     }
3264   return false;
3265 }
3266
3267
3268 /* Possibly define a builtin function with one or two names.  BUILTIN_NAME
3269    is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3270    of these may be NULL (though both being NULL is useless).
3271    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3272    TYPE is the type of the function with the ordinary name.  These
3273    may differ if the ordinary name is declared with a looser type to avoid
3274    conflicts with headers.  FUNCTION_CODE and CL are as for
3275    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
3276    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3277    If NONANSI_P is true, the name NAME is treated as a non-ANSI name;
3278    ATTRS is the tree list representing the builtin's function attributes.
3279    Returns the declaration of BUILTIN_NAME, if any, otherwise
3280    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
3281    or if NONANSI_P and flag_no_nonansi_builtin.  */
3282
3283 static tree
3284 builtin_function_2 (const char *builtin_name, const char *name,
3285                     tree builtin_type, tree type,
3286                     enum built_in_function function_code,
3287                     enum built_in_class cl, int library_name_p,
3288                     bool nonansi_p, tree attrs)
3289 {
3290   tree bdecl = NULL_TREE;
3291   tree decl = NULL_TREE;
3292
3293   if (builtin_name != 0)
3294     bdecl = lang_hooks.builtin_function (builtin_name, builtin_type,
3295                                          function_code, cl,
3296                                          library_name_p ? name : NULL, attrs);
3297
3298   if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3299       && !(nonansi_p && flag_no_nonansi_builtin))
3300     decl = lang_hooks.builtin_function (name, type, function_code, cl,
3301                                         NULL, attrs);
3302
3303   return (bdecl != 0 ? bdecl : decl);
3304 }
3305 \f
3306 /* Nonzero if the type T promotes to int.  This is (nearly) the
3307    integral promotions defined in ISO C99 6.3.1.1/2.  */
3308
3309 bool
3310 c_promoting_integer_type_p (tree t)
3311 {
3312   switch (TREE_CODE (t))
3313     {
3314     case INTEGER_TYPE:
3315       return (TYPE_MAIN_VARIANT (t) == char_type_node
3316               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3317               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3318               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3319               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3320               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3321
3322     case ENUMERAL_TYPE:
3323       /* ??? Technically all enumerations not larger than an int
3324          promote to an int.  But this is used along code paths
3325          that only want to notice a size change.  */
3326       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3327
3328     case BOOLEAN_TYPE:
3329       return 1;
3330
3331     default:
3332       return 0;
3333     }
3334 }
3335
3336 /* Return 1 if PARMS specifies a fixed number of parameters
3337    and none of their types is affected by default promotions.  */
3338
3339 int
3340 self_promoting_args_p (tree parms)
3341 {
3342   tree t;
3343   for (t = parms; t; t = TREE_CHAIN (t))
3344     {
3345       tree type = TREE_VALUE (t);
3346
3347       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3348         return 0;
3349
3350       if (type == 0)
3351         return 0;
3352
3353       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3354         return 0;
3355
3356       if (c_promoting_integer_type_p (type))
3357         return 0;
3358     }
3359   return 1;
3360 }
3361
3362 /* Recursively examines the array elements of TYPE, until a non-array
3363    element type is found.  */
3364
3365 tree
3366 strip_array_types (tree type)
3367 {
3368   while (TREE_CODE (type) == ARRAY_TYPE)
3369     type = TREE_TYPE (type);
3370
3371   return type;
3372 }
3373
3374 /* Recursively remove any '*' or '&' operator from TYPE.  */
3375 tree
3376 strip_pointer_operator (tree t)
3377 {
3378   while (POINTER_TYPE_P (t))
3379     t = TREE_TYPE (t);
3380   return t;
3381 }
3382
3383 /* Walk the statement tree, rooted at *tp.  Apply FUNC to all the
3384    sub-trees of *TP in a pre-order traversal.  FUNC is called with the
3385    DATA and the address of each sub-tree.  If FUNC returns a non-NULL
3386    value, the traversal is aborted, and the value returned by FUNC is
3387    returned.  If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3388    the node being visited are not walked.
3389
3390    We don't need a without_duplicates variant of this one because the
3391    statement tree is a tree, not a graph.  */
3392
3393 tree
3394 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3395 {
3396   enum tree_code code;
3397   int walk_subtrees;
3398   tree result;
3399   int i, len;
3400
3401 #define WALK_SUBTREE(NODE)                              \
3402   do                                                    \
3403     {                                                   \
3404       result = walk_stmt_tree (&(NODE), func, data);    \
3405       if (result)                                       \
3406         return result;                                  \
3407     }                                                   \
3408   while (0)
3409
3410   /* Skip empty subtrees.  */
3411   if (!*tp)
3412     return NULL_TREE;
3413
3414   /* Skip subtrees below non-statement nodes.  */
3415   if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3416     return NULL_TREE;
3417
3418   /* Call the function.  */
3419   walk_subtrees = 1;
3420   result = (*func) (tp, &walk_subtrees, data);
3421
3422   /* If we found something, return it.  */
3423   if (result)
3424     return result;
3425
3426   /* FUNC may have modified the tree, recheck that we're looking at a
3427      statement node.  */
3428   code = TREE_CODE (*tp);
3429   if (!STATEMENT_CODE_P (code))
3430     return NULL_TREE;
3431
3432   /* Visit the subtrees unless FUNC decided that there was nothing
3433      interesting below this point in the tree.  */
3434   if (walk_subtrees)
3435     {
3436       /* Walk over all the sub-trees of this operand.  Statement nodes
3437          never contain RTL, and we needn't worry about TARGET_EXPRs.  */
3438       len = TREE_CODE_LENGTH (code);
3439
3440       /* Go through the subtrees.  We need to do this in forward order so
3441          that the scope of a FOR_EXPR is handled properly.  */
3442       for (i = 0; i < len; ++i)
3443         WALK_SUBTREE (TREE_OPERAND (*tp, i));
3444     }
3445
3446   /* Finally visit the chain.  This can be tail-recursion optimized if
3447      we write it this way.  */
3448   return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3449
3450 #undef WALK_SUBTREE
3451 }
3452
3453 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3454    representing case labels, or NULL_TREE for a `default' label.
3455    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3456    K2, and 0 if K1 and K2 are equal.  */
3457
3458 int
3459 case_compare (splay_tree_key k1, splay_tree_key k2)
3460 {
3461   /* Consider a NULL key (such as arises with a `default' label) to be
3462      smaller than anything else.  */
3463   if (!k1)
3464     return k2 ? -1 : 0;
3465   else if (!k2)
3466     return k1 ? 1 : 0;
3467
3468   return tree_int_cst_compare ((tree) k1, (tree) k2);
3469 }
3470
3471 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3472    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3473    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3474    case label was declared using the usual C/C++ syntax, rather than