OSDN Git Service

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