OSDN Git Service

2005-10-23 Andrew Pinski <pinskia@physics.uc.edu>
[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 /* Tells the compiler what is the constant string class for Objc.  */
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_force (*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              && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE || 
976                  TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
977              && INTEGRAL_TYPE_P (TREE_TYPE (t1))
978                 == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
979 }
980
981 /* Convert EXPR to TYPE, warning about conversion problems with constants.
982    Invoke this function on every expression that is converted implicitly,
983    i.e. because of language rules and not because of an explicit cast.  */
984
985 tree
986 convert_and_check (tree type, tree expr)
987 {
988   tree t = convert (type, expr);
989   if (TREE_CODE (t) == INTEGER_CST)
990     {
991       if (TREE_OVERFLOW (t))
992         {
993           TREE_OVERFLOW (t) = 0;
994
995           /* Do not diagnose overflow in a constant expression merely
996              because a conversion overflowed.  */
997           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
998
999           /* No warning for converting 0x80000000 to int.  */
1000           if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1001                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1002                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1003             /* If EXPR fits in the unsigned version of TYPE,
1004                don't warn unless pedantic.  */
1005             if ((pedantic
1006                  || TYPE_UNSIGNED (type)
1007                  || !constant_fits_type_p (expr,
1008                                            c_common_unsigned_type (type)))
1009                 && skip_evaluation == 0)
1010               warning (0, "overflow in implicit constant conversion");
1011         }
1012       else
1013         unsigned_conversion_warning (t, expr);
1014     }
1015   return t;
1016 }
1017 \f
1018 /* A node in a list that describes references to variables (EXPR), which are
1019    either read accesses if WRITER is zero, or write accesses, in which case
1020    WRITER is the parent of EXPR.  */
1021 struct tlist
1022 {
1023   struct tlist *next;
1024   tree expr, writer;
1025 };
1026
1027 /* Used to implement a cache the results of a call to verify_tree.  We only
1028    use this for SAVE_EXPRs.  */
1029 struct tlist_cache
1030 {
1031   struct tlist_cache *next;
1032   struct tlist *cache_before_sp;
1033   struct tlist *cache_after_sp;
1034   tree expr;
1035 };
1036
1037 /* Obstack to use when allocating tlist structures, and corresponding
1038    firstobj.  */
1039 static struct obstack tlist_obstack;
1040 static char *tlist_firstobj = 0;
1041
1042 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1043    warnings.  */
1044 static struct tlist *warned_ids;
1045 /* SAVE_EXPRs need special treatment.  We process them only once and then
1046    cache the results.  */
1047 static struct tlist_cache *save_expr_cache;
1048
1049 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1050 static void merge_tlist (struct tlist **, struct tlist *, int);
1051 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1052 static int warning_candidate_p (tree);
1053 static void warn_for_collisions (struct tlist *);
1054 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1055 static struct tlist *new_tlist (struct tlist *, tree, tree);
1056
1057 /* Create a new struct tlist and fill in its fields.  */
1058 static struct tlist *
1059 new_tlist (struct tlist *next, tree t, tree writer)
1060 {
1061   struct tlist *l;
1062   l = XOBNEW (&tlist_obstack, struct tlist);
1063   l->next = next;
1064   l->expr = t;
1065   l->writer = writer;
1066   return l;
1067 }
1068
1069 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1070    is nonnull, we ignore any node we find which has a writer equal to it.  */
1071
1072 static void
1073 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1074 {
1075   while (add)
1076     {
1077       struct tlist *next = add->next;
1078       if (!copy)
1079         add->next = *to;
1080       if (!exclude_writer || add->writer != exclude_writer)
1081         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1082       add = next;
1083     }
1084 }
1085
1086 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1087    each variable that already exists in TO, no new node is added; however if
1088    there is a write access recorded in ADD, and an occurrence on TO is only
1089    a read access, then the occurrence in TO will be modified to record the
1090    write.  */
1091
1092 static void
1093 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1094 {
1095   struct tlist **end = to;
1096
1097   while (*end)
1098     end = &(*end)->next;
1099
1100   while (add)
1101     {
1102       int found = 0;
1103       struct tlist *tmp2;
1104       struct tlist *next = add->next;
1105
1106       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1107         if (tmp2->expr == add->expr)
1108           {
1109             found = 1;
1110             if (!tmp2->writer)
1111               tmp2->writer = add->writer;
1112           }
1113       if (!found)
1114         {
1115           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1116           end = &(*end)->next;
1117           *end = 0;
1118         }
1119       add = next;
1120     }
1121 }
1122
1123 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1124    references in list LIST conflict with it, excluding reads if ONLY writers
1125    is nonzero.  */
1126
1127 static void
1128 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1129                        int only_writes)
1130 {
1131   struct tlist *tmp;
1132
1133   /* Avoid duplicate warnings.  */
1134   for (tmp = warned_ids; tmp; tmp = tmp->next)
1135     if (tmp->expr == written)
1136       return;
1137
1138   while (list)
1139     {
1140       if (list->expr == written
1141           && list->writer != writer
1142           && (!only_writes || list->writer)
1143           && DECL_NAME (list->expr))
1144         {
1145           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1146           warning (0, "operation on %qE may be undefined", list->expr);
1147         }
1148       list = list->next;
1149     }
1150 }
1151
1152 /* Given a list LIST of references to variables, find whether any of these
1153    can cause conflicts due to missing sequence points.  */
1154
1155 static void
1156 warn_for_collisions (struct tlist *list)
1157 {
1158   struct tlist *tmp;
1159
1160   for (tmp = list; tmp; tmp = tmp->next)
1161     {
1162       if (tmp->writer)
1163         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1164     }
1165 }
1166
1167 /* Return nonzero if X is a tree that can be verified by the sequence point
1168    warnings.  */
1169 static int
1170 warning_candidate_p (tree x)
1171 {
1172   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1173 }
1174
1175 /* Walk the tree X, and record accesses to variables.  If X is written by the
1176    parent tree, WRITER is the parent.
1177    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1178    expression or its only operand forces a sequence point, then everything up
1179    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1180    in PNO_SP.
1181    Once we return, we will have emitted warnings if any subexpression before
1182    such a sequence point could be undefined.  On a higher level, however, the
1183    sequence point may not be relevant, and we'll merge the two lists.
1184
1185    Example: (b++, a) + b;
1186    The call that processes the COMPOUND_EXPR will store the increment of B
1187    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1188    processes the PLUS_EXPR will need to merge the two lists so that
1189    eventually, all accesses end up on the same list (and we'll warn about the
1190    unordered subexpressions b++ and b.
1191
1192    A note on merging.  If we modify the former example so that our expression
1193    becomes
1194      (b++, b) + a
1195    care must be taken not simply to add all three expressions into the final
1196    PNO_SP list.  The function merge_tlist takes care of that by merging the
1197    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1198    way, so that no more than one access to B is recorded.  */
1199
1200 static void
1201 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1202              tree writer)
1203 {
1204   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1205   enum tree_code code;
1206   enum tree_code_class cl;
1207
1208   /* X may be NULL if it is the operand of an empty statement expression
1209      ({ }).  */
1210   if (x == NULL)
1211     return;
1212
1213  restart:
1214   code = TREE_CODE (x);
1215   cl = TREE_CODE_CLASS (code);
1216
1217   if (warning_candidate_p (x))
1218     {
1219       *pno_sp = new_tlist (*pno_sp, x, writer);
1220       return;
1221     }
1222
1223   switch (code)
1224     {
1225     case CONSTRUCTOR:
1226       return;
1227
1228     case COMPOUND_EXPR:
1229     case TRUTH_ANDIF_EXPR:
1230     case TRUTH_ORIF_EXPR:
1231       tmp_before = tmp_nosp = tmp_list3 = 0;
1232       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1233       warn_for_collisions (tmp_nosp);
1234       merge_tlist (pbefore_sp, tmp_before, 0);
1235       merge_tlist (pbefore_sp, tmp_nosp, 0);
1236       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1237       merge_tlist (pbefore_sp, tmp_list3, 0);
1238       return;
1239
1240     case COND_EXPR:
1241       tmp_before = tmp_list2 = 0;
1242       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1243       warn_for_collisions (tmp_list2);
1244       merge_tlist (pbefore_sp, tmp_before, 0);
1245       merge_tlist (pbefore_sp, tmp_list2, 1);
1246
1247       tmp_list3 = tmp_nosp = 0;
1248       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1249       warn_for_collisions (tmp_nosp);
1250       merge_tlist (pbefore_sp, tmp_list3, 0);
1251
1252       tmp_list3 = tmp_list2 = 0;
1253       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1254       warn_for_collisions (tmp_list2);
1255       merge_tlist (pbefore_sp, tmp_list3, 0);
1256       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1257          two first, to avoid warning for (a ? b++ : b++).  */
1258       merge_tlist (&tmp_nosp, tmp_list2, 0);
1259       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1260       return;
1261
1262     case PREDECREMENT_EXPR:
1263     case PREINCREMENT_EXPR:
1264     case POSTDECREMENT_EXPR:
1265     case POSTINCREMENT_EXPR:
1266       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1267       return;
1268
1269     case MODIFY_EXPR:
1270       tmp_before = tmp_nosp = tmp_list3 = 0;
1271       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1272       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1273       /* Expressions inside the LHS are not ordered wrt. the sequence points
1274          in the RHS.  Example:
1275            *a = (a++, 2)
1276          Despite the fact that the modification of "a" is in the before_sp
1277          list (tmp_before), it conflicts with the use of "a" in the LHS.
1278          We can handle this by adding the contents of tmp_list3
1279          to those of tmp_before, and redoing the collision warnings for that
1280          list.  */
1281       add_tlist (&tmp_before, tmp_list3, x, 1);
1282       warn_for_collisions (tmp_before);
1283       /* Exclude the LHS itself here; we first have to merge it into the
1284          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1285          didn't exclude the LHS, we'd get it twice, once as a read and once
1286          as a write.  */
1287       add_tlist (pno_sp, tmp_list3, x, 0);
1288       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1289
1290       merge_tlist (pbefore_sp, tmp_before, 0);
1291       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1292         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1293       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1294       return;
1295
1296     case CALL_EXPR:
1297       /* We need to warn about conflicts among arguments and conflicts between
1298          args and the function address.  Side effects of the function address,
1299          however, are not ordered by the sequence point of the call.  */
1300       tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1301       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1302       if (TREE_OPERAND (x, 1))
1303         verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1304       merge_tlist (&tmp_list3, tmp_list2, 0);
1305       add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1306       add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1307       warn_for_collisions (tmp_before);
1308       add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1309       return;
1310
1311     case TREE_LIST:
1312       /* Scan all the list, e.g. indices of multi dimensional array.  */
1313       while (x)
1314         {
1315           tmp_before = tmp_nosp = 0;
1316           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1317           merge_tlist (&tmp_nosp, tmp_before, 0);
1318           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1319           x = TREE_CHAIN (x);
1320         }
1321       return;
1322
1323     case SAVE_EXPR:
1324       {
1325         struct tlist_cache *t;
1326         for (t = save_expr_cache; t; t = t->next)
1327           if (t->expr == x)
1328             break;
1329
1330         if (!t)
1331           {
1332             t = XOBNEW (&tlist_obstack, struct tlist_cache);
1333             t->next = save_expr_cache;
1334             t->expr = x;
1335             save_expr_cache = t;
1336
1337             tmp_before = tmp_nosp = 0;
1338             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1339             warn_for_collisions (tmp_nosp);
1340
1341             tmp_list3 = 0;
1342             while (tmp_nosp)
1343               {
1344                 struct tlist *t = tmp_nosp;
1345                 tmp_nosp = t->next;
1346                 merge_tlist (&tmp_list3, t, 0);
1347               }
1348             t->cache_before_sp = tmp_before;
1349             t->cache_after_sp = tmp_list3;
1350           }
1351         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1352         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1353         return;
1354       }
1355
1356     default:
1357       /* For other expressions, simply recurse on their operands.
1358          Manual tail recursion for unary expressions.
1359          Other non-expressions need not be processed.  */
1360       if (cl == tcc_unary)
1361         {
1362           x = TREE_OPERAND (x, 0);
1363           writer = 0;
1364           goto restart;
1365         }
1366       else if (IS_EXPR_CODE_CLASS (cl))
1367         {
1368           int lp;
1369           int max = TREE_CODE_LENGTH (TREE_CODE (x));
1370           for (lp = 0; lp < max; lp++)
1371             {
1372               tmp_before = tmp_nosp = 0;
1373               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1374               merge_tlist (&tmp_nosp, tmp_before, 0);
1375               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1376             }
1377         }
1378       return;
1379     }
1380 }
1381
1382 /* Try to warn for undefined behavior in EXPR due to missing sequence
1383    points.  */
1384
1385 void
1386 verify_sequence_points (tree expr)
1387 {
1388   struct tlist *before_sp = 0, *after_sp = 0;
1389
1390   warned_ids = 0;
1391   save_expr_cache = 0;
1392   if (tlist_firstobj == 0)
1393     {
1394       gcc_obstack_init (&tlist_obstack);
1395       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1396     }
1397
1398   verify_tree (expr, &before_sp, &after_sp, 0);
1399   warn_for_collisions (after_sp);
1400   obstack_free (&tlist_obstack, tlist_firstobj);
1401 }
1402 \f
1403 /* Validate the expression after `case' and apply default promotions.  */
1404
1405 static tree
1406 check_case_value (tree value)
1407 {
1408   if (value == NULL_TREE)
1409     return value;
1410
1411   /* ??? Can we ever get nops here for a valid case value?  We
1412      shouldn't for C.  */
1413   STRIP_TYPE_NOPS (value);
1414   /* In C++, the following is allowed:
1415
1416        const int i = 3;
1417        switch (...) { case i: ... }
1418
1419      So, we try to reduce the VALUE to a constant that way.  */
1420   if (c_dialect_cxx ())
1421     {
1422       value = decl_constant_value (value);
1423       STRIP_TYPE_NOPS (value);
1424       value = fold (value);
1425     }
1426
1427   if (TREE_CODE (value) == INTEGER_CST)
1428     /* Promote char or short to int.  */
1429     value = perform_integral_promotions (value);
1430   else if (value != error_mark_node)
1431     {
1432       error ("case label does not reduce to an integer constant");
1433       value = error_mark_node;
1434     }
1435
1436   constant_expression_warning (value);
1437
1438   return value;
1439 }
1440 \f
1441 /* See if the case values LOW and HIGH are in the range of the original
1442    type (i.e. before the default conversion to int) of the switch testing
1443    expression.
1444    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1445    the type before promoting it.  CASE_LOW_P is a pointer to the lower
1446    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1447    if the case is not a case range.
1448    The caller has to make sure that we are not called with NULL for
1449    CASE_LOW_P (i.e. the default case).
1450    Returns true if the case label is in range of ORIG_TYPE (saturated or
1451    untouched) or false if the label is out of range.  */
1452
1453 static bool
1454 check_case_bounds (tree type, tree orig_type,
1455                    tree *case_low_p, tree *case_high_p)
1456 {
1457   tree min_value, max_value;
1458   tree case_low = *case_low_p;
1459   tree case_high = case_high_p ? *case_high_p : case_low;
1460
1461   /* If there was a problem with the original type, do nothing.  */
1462   if (orig_type == error_mark_node)
1463     return true;
1464
1465   min_value = TYPE_MIN_VALUE (orig_type);
1466   max_value = TYPE_MAX_VALUE (orig_type);
1467
1468   /* Case label is less than minimum for type.  */
1469   if (tree_int_cst_compare (case_low, min_value) < 0
1470       && tree_int_cst_compare (case_high, min_value) < 0)
1471     {
1472       warning (0, "case label value is less than minimum value for type");
1473       return false;
1474     }
1475
1476   /* Case value is greater than maximum for type.  */
1477   if (tree_int_cst_compare (case_low, max_value) > 0
1478       && tree_int_cst_compare (case_high, max_value) > 0)
1479     {
1480       warning (0, "case label value exceeds maximum value for type");
1481       return false;
1482     }
1483
1484   /* Saturate lower case label value to minimum.  */
1485   if (tree_int_cst_compare (case_high, min_value) >= 0
1486       && tree_int_cst_compare (case_low, min_value) < 0)
1487     {
1488       warning (0, "lower value in case label range"
1489                " less than minimum value for type");
1490       case_low = min_value;
1491     }
1492
1493   /* Saturate upper case label value to maximum.  */
1494   if (tree_int_cst_compare (case_low, max_value) <= 0
1495       && tree_int_cst_compare (case_high, max_value) > 0)
1496     {
1497       warning (0, "upper value in case label range"
1498                " exceeds maximum value for type");
1499       case_high = max_value;
1500     }
1501
1502   if (*case_low_p != case_low)
1503     *case_low_p = convert (type, case_low);
1504   if (case_high_p && *case_high_p != case_high)
1505     *case_high_p = convert (type, case_high);
1506
1507   return true;
1508 }
1509 \f
1510 /* Return an integer type with BITS bits of precision,
1511    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1512
1513 tree
1514 c_common_type_for_size (unsigned int bits, int unsignedp)
1515 {
1516   if (bits == TYPE_PRECISION (integer_type_node))
1517     return unsignedp ? unsigned_type_node : integer_type_node;
1518
1519   if (bits == TYPE_PRECISION (signed_char_type_node))
1520     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1521
1522   if (bits == TYPE_PRECISION (short_integer_type_node))
1523     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1524
1525   if (bits == TYPE_PRECISION (long_integer_type_node))
1526     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1527
1528   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1529     return (unsignedp ? long_long_unsigned_type_node
1530             : long_long_integer_type_node);
1531
1532   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1533     return (unsignedp ? widest_unsigned_literal_type_node
1534             : widest_integer_literal_type_node);
1535
1536   if (bits <= TYPE_PRECISION (intQI_type_node))
1537     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1538
1539   if (bits <= TYPE_PRECISION (intHI_type_node))
1540     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1541
1542   if (bits <= TYPE_PRECISION (intSI_type_node))
1543     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1544
1545   if (bits <= TYPE_PRECISION (intDI_type_node))
1546     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1547
1548   return 0;
1549 }
1550
1551 /* Used for communication between c_common_type_for_mode and
1552    c_register_builtin_type.  */
1553 static GTY(()) tree registered_builtin_types;
1554
1555 /* Return a data type that has machine mode MODE.
1556    If the mode is an integer,
1557    then UNSIGNEDP selects between signed and unsigned types.  */
1558
1559 tree
1560 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1561 {
1562   tree t;
1563
1564   if (mode == TYPE_MODE (integer_type_node))
1565     return unsignedp ? unsigned_type_node : integer_type_node;
1566
1567   if (mode == TYPE_MODE (signed_char_type_node))
1568     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1569
1570   if (mode == TYPE_MODE (short_integer_type_node))
1571     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1572
1573   if (mode == TYPE_MODE (long_integer_type_node))
1574     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1575
1576   if (mode == TYPE_MODE (long_long_integer_type_node))
1577     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1578
1579   if (mode == TYPE_MODE (widest_integer_literal_type_node))
1580     return unsignedp ? widest_unsigned_literal_type_node
1581                      : widest_integer_literal_type_node;
1582
1583   if (mode == QImode)
1584     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1585
1586   if (mode == HImode)
1587     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1588
1589   if (mode == SImode)
1590     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1591
1592   if (mode == DImode)
1593     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1594
1595 #if HOST_BITS_PER_WIDE_INT >= 64
1596   if (mode == TYPE_MODE (intTI_type_node))
1597     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1598 #endif
1599
1600   if (mode == TYPE_MODE (float_type_node))
1601     return float_type_node;
1602
1603   if (mode == TYPE_MODE (double_type_node))
1604     return double_type_node;
1605
1606   if (mode == TYPE_MODE (long_double_type_node))
1607     return long_double_type_node;
1608
1609   if (mode == TYPE_MODE (void_type_node))
1610     return void_type_node;
1611
1612   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1613     return (unsignedp
1614             ? make_unsigned_type (GET_MODE_PRECISION (mode))
1615             : make_signed_type (GET_MODE_PRECISION (mode)));
1616
1617   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1618     return (unsignedp
1619             ? make_unsigned_type (GET_MODE_PRECISION (mode))
1620             : make_signed_type (GET_MODE_PRECISION (mode)));
1621
1622   if (COMPLEX_MODE_P (mode))
1623     {
1624       enum machine_mode inner_mode;
1625       tree inner_type;
1626
1627       if (mode == TYPE_MODE (complex_float_type_node))
1628         return complex_float_type_node;
1629       if (mode == TYPE_MODE (complex_double_type_node))
1630         return complex_double_type_node;
1631       if (mode == TYPE_MODE (complex_long_double_type_node))
1632         return complex_long_double_type_node;
1633
1634       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1635         return complex_integer_type_node;
1636
1637       inner_mode = GET_MODE_INNER (mode);
1638       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1639       if (inner_type != NULL_TREE)
1640         return build_complex_type (inner_type);
1641     }
1642   else if (VECTOR_MODE_P (mode))
1643     {
1644       enum machine_mode inner_mode = GET_MODE_INNER (mode);
1645       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1646       if (inner_type != NULL_TREE)
1647         return build_vector_type_for_mode (inner_type, mode);
1648     }
1649
1650   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1651     if (TYPE_MODE (TREE_VALUE (t)) == mode)
1652       return TREE_VALUE (t);
1653
1654   return 0;
1655 }
1656
1657 /* Return an unsigned type the same as TYPE in other respects.  */
1658 tree
1659 c_common_unsigned_type (tree type)
1660 {
1661   tree type1 = TYPE_MAIN_VARIANT (type);
1662   if (type1 == signed_char_type_node || type1 == char_type_node)
1663     return unsigned_char_type_node;
1664   if (type1 == integer_type_node)
1665     return unsigned_type_node;
1666   if (type1 == short_integer_type_node)
1667     return short_unsigned_type_node;
1668   if (type1 == long_integer_type_node)
1669     return long_unsigned_type_node;
1670   if (type1 == long_long_integer_type_node)
1671     return long_long_unsigned_type_node;
1672   if (type1 == widest_integer_literal_type_node)
1673     return widest_unsigned_literal_type_node;
1674 #if HOST_BITS_PER_WIDE_INT >= 64
1675   if (type1 == intTI_type_node)
1676     return unsigned_intTI_type_node;
1677 #endif
1678   if (type1 == intDI_type_node)
1679     return unsigned_intDI_type_node;
1680   if (type1 == intSI_type_node)
1681     return unsigned_intSI_type_node;
1682   if (type1 == intHI_type_node)
1683     return unsigned_intHI_type_node;
1684   if (type1 == intQI_type_node)
1685     return unsigned_intQI_type_node;
1686
1687   return c_common_signed_or_unsigned_type (1, type);
1688 }
1689
1690 /* Return a signed type the same as TYPE in other respects.  */
1691
1692 tree
1693 c_common_signed_type (tree type)
1694 {
1695   tree type1 = TYPE_MAIN_VARIANT (type);
1696   if (type1 == unsigned_char_type_node || type1 == char_type_node)
1697     return signed_char_type_node;
1698   if (type1 == unsigned_type_node)
1699     return integer_type_node;
1700   if (type1 == short_unsigned_type_node)
1701     return short_integer_type_node;
1702   if (type1 == long_unsigned_type_node)
1703     return long_integer_type_node;
1704   if (type1 == long_long_unsigned_type_node)
1705     return long_long_integer_type_node;
1706   if (type1 == widest_unsigned_literal_type_node)
1707     return widest_integer_literal_type_node;
1708 #if HOST_BITS_PER_WIDE_INT >= 64
1709   if (type1 == unsigned_intTI_type_node)
1710     return intTI_type_node;
1711 #endif
1712   if (type1 == unsigned_intDI_type_node)
1713     return intDI_type_node;
1714   if (type1 == unsigned_intSI_type_node)
1715     return intSI_type_node;
1716   if (type1 == unsigned_intHI_type_node)
1717     return intHI_type_node;
1718   if (type1 == unsigned_intQI_type_node)
1719     return intQI_type_node;
1720
1721   return c_common_signed_or_unsigned_type (0, type);
1722 }
1723
1724 /* Return a type the same as TYPE except unsigned or
1725    signed according to UNSIGNEDP.  */
1726
1727 tree
1728 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1729 {
1730   if (!INTEGRAL_TYPE_P (type)
1731       || TYPE_UNSIGNED (type) == unsignedp)
1732     return type;
1733
1734   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1735      the precision; they have precision set to match their range, but
1736      may use a wider mode to match an ABI.  If we change modes, we may
1737      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
1738      the precision as well, so as to yield correct results for
1739      bit-field types.  C++ does not have these separate bit-field
1740      types, and producing a signed or unsigned variant of an
1741      ENUMERAL_TYPE may cause other problems as well.  */
1742
1743 #define TYPE_OK(node)                                                       \
1744   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
1745    && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1746   if (TYPE_OK (signed_char_type_node))
1747     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1748   if (TYPE_OK (integer_type_node))
1749     return unsignedp ? unsigned_type_node : integer_type_node;
1750   if (TYPE_OK (short_integer_type_node))
1751     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1752   if (TYPE_OK (long_integer_type_node))
1753     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1754   if (TYPE_OK (long_long_integer_type_node))
1755     return (unsignedp ? long_long_unsigned_type_node
1756             : long_long_integer_type_node);
1757   if (TYPE_OK (widest_integer_literal_type_node))
1758     return (unsignedp ? widest_unsigned_literal_type_node
1759             : widest_integer_literal_type_node);
1760
1761 #if HOST_BITS_PER_WIDE_INT >= 64
1762   if (TYPE_OK (intTI_type_node))
1763     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1764 #endif
1765   if (TYPE_OK (intDI_type_node))
1766     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1767   if (TYPE_OK (intSI_type_node))
1768     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1769   if (TYPE_OK (intHI_type_node))
1770     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1771   if (TYPE_OK (intQI_type_node))
1772     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1773 #undef TYPE_OK
1774
1775   if (c_dialect_cxx ())
1776     return type;
1777   else
1778     return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1779 }
1780
1781 /* The C version of the register_builtin_type langhook.  */
1782
1783 void
1784 c_register_builtin_type (tree type, const char* name)
1785 {
1786   tree decl;
1787
1788   decl = build_decl (TYPE_DECL, get_identifier (name), type);
1789   DECL_ARTIFICIAL (decl) = 1;
1790   if (!TYPE_NAME (type))
1791     TYPE_NAME (type) = decl;
1792   pushdecl (decl);
1793
1794   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1795 }
1796
1797 \f
1798 /* Return the minimum number of bits needed to represent VALUE in a
1799    signed or unsigned type, UNSIGNEDP says which.  */
1800
1801 unsigned int
1802 min_precision (tree value, int unsignedp)
1803 {
1804   int log;
1805
1806   /* If the value is negative, compute its negative minus 1.  The latter
1807      adjustment is because the absolute value of the largest negative value
1808      is one larger than the largest positive value.  This is equivalent to
1809      a bit-wise negation, so use that operation instead.  */
1810
1811   if (tree_int_cst_sgn (value) < 0)
1812     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
1813
1814   /* Return the number of bits needed, taking into account the fact
1815      that we need one more bit for a signed than unsigned type.  */
1816
1817   if (integer_zerop (value))
1818     log = 0;
1819   else
1820     log = tree_floor_log2 (value);
1821
1822   return log + 1 + !unsignedp;
1823 }
1824 \f
1825 /* Print an error message for invalid operands to arith operation
1826    CODE.  NOP_EXPR is used as a special case (see
1827    c_common_truthvalue_conversion).  */
1828
1829 void
1830 binary_op_error (enum tree_code code)
1831 {
1832   const char *opname;
1833
1834   switch (code)
1835     {
1836     case NOP_EXPR:
1837       error ("invalid truth-value expression");
1838       return;
1839
1840     case PLUS_EXPR:
1841       opname = "+"; break;
1842     case MINUS_EXPR:
1843       opname = "-"; break;
1844     case MULT_EXPR:
1845       opname = "*"; break;
1846     case MAX_EXPR:
1847       opname = "max"; break;
1848     case MIN_EXPR:
1849       opname = "min"; break;
1850     case EQ_EXPR:
1851       opname = "=="; break;
1852     case NE_EXPR:
1853       opname = "!="; break;
1854     case LE_EXPR:
1855       opname = "<="; break;
1856     case GE_EXPR:
1857       opname = ">="; break;
1858     case LT_EXPR:
1859       opname = "<"; break;
1860     case GT_EXPR:
1861       opname = ">"; break;
1862     case LSHIFT_EXPR:
1863       opname = "<<"; break;
1864     case RSHIFT_EXPR:
1865       opname = ">>"; break;
1866     case TRUNC_MOD_EXPR:
1867     case FLOOR_MOD_EXPR:
1868       opname = "%"; break;
1869     case TRUNC_DIV_EXPR:
1870     case FLOOR_DIV_EXPR:
1871       opname = "/"; break;
1872     case BIT_AND_EXPR:
1873       opname = "&"; break;
1874     case BIT_IOR_EXPR:
1875       opname = "|"; break;
1876     case TRUTH_ANDIF_EXPR:
1877       opname = "&&"; break;
1878     case TRUTH_ORIF_EXPR:
1879       opname = "||"; break;
1880     case BIT_XOR_EXPR:
1881       opname = "^"; break;
1882     default:
1883       gcc_unreachable ();
1884     }
1885   error ("invalid operands to binary %s", opname);
1886 }
1887 \f
1888 /* Subroutine of build_binary_op, used for comparison operations.
1889    See if the operands have both been converted from subword integer types
1890    and, if so, perhaps change them both back to their original type.
1891    This function is also responsible for converting the two operands
1892    to the proper common type for comparison.
1893
1894    The arguments of this function are all pointers to local variables
1895    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1896    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1897
1898    If this function returns nonzero, it means that the comparison has
1899    a constant value.  What this function returns is an expression for
1900    that value.  */
1901
1902 tree
1903 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
1904                  enum tree_code *rescode_ptr)
1905 {
1906   tree type;
1907   tree op0 = *op0_ptr;
1908   tree op1 = *op1_ptr;
1909   int unsignedp0, unsignedp1;
1910   int real1, real2;
1911   tree primop0, primop1;
1912   enum tree_code code = *rescode_ptr;
1913
1914   /* Throw away any conversions to wider types
1915      already present in the operands.  */
1916
1917   primop0 = get_narrower (op0, &unsignedp0);
1918   primop1 = get_narrower (op1, &unsignedp1);
1919
1920   /* Handle the case that OP0 does not *contain* a conversion
1921      but it *requires* conversion to FINAL_TYPE.  */
1922
1923   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1924     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1925   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1926     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1927
1928   /* If one of the operands must be floated, we cannot optimize.  */
1929   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1930   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1931
1932   /* If first arg is constant, swap the args (changing operation
1933      so value is preserved), for canonicalization.  Don't do this if
1934      the second arg is 0.  */
1935
1936   if (TREE_CONSTANT (primop0)
1937       && !integer_zerop (primop1) && !real_zerop (primop1))
1938     {
1939       tree tem = primop0;
1940       int temi = unsignedp0;
1941       primop0 = primop1;
1942       primop1 = tem;
1943       tem = op0;
1944       op0 = op1;
1945       op1 = tem;
1946       *op0_ptr = op0;
1947       *op1_ptr = op1;
1948       unsignedp0 = unsignedp1;
1949       unsignedp1 = temi;
1950       temi = real1;
1951       real1 = real2;
1952       real2 = temi;
1953
1954       switch (code)
1955         {
1956         case LT_EXPR:
1957           code = GT_EXPR;
1958           break;
1959         case GT_EXPR:
1960           code = LT_EXPR;
1961           break;
1962         case LE_EXPR:
1963           code = GE_EXPR;
1964           break;
1965         case GE_EXPR:
1966           code = LE_EXPR;
1967           break;
1968         default:
1969           break;
1970         }
1971       *rescode_ptr = code;
1972     }
1973
1974   /* If comparing an integer against a constant more bits wide,
1975      maybe we can deduce a value of 1 or 0 independent of the data.
1976      Or else truncate the constant now
1977      rather than extend the variable at run time.
1978
1979      This is only interesting if the constant is the wider arg.
1980      Also, it is not safe if the constant is unsigned and the
1981      variable arg is signed, since in this case the variable
1982      would be sign-extended and then regarded as unsigned.
1983      Our technique fails in this case because the lowest/highest
1984      possible unsigned results don't follow naturally from the
1985      lowest/highest possible values of the variable operand.
1986      For just EQ_EXPR and NE_EXPR there is another technique that
1987      could be used: see if the constant can be faithfully represented
1988      in the other operand's type, by truncating it and reextending it
1989      and see if that preserves the constant's value.  */
1990
1991   if (!real1 && !real2
1992       && TREE_CODE (primop1) == INTEGER_CST
1993       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1994     {
1995       int min_gt, max_gt, min_lt, max_lt;
1996       tree maxval, minval;
1997       /* 1 if comparison is nominally unsigned.  */
1998       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
1999       tree val;
2000
2001       type = c_common_signed_or_unsigned_type (unsignedp0,
2002                                                TREE_TYPE (primop0));
2003
2004       maxval = TYPE_MAX_VALUE (type);
2005       minval = TYPE_MIN_VALUE (type);
2006
2007       if (unsignedp && !unsignedp0)
2008         *restype_ptr = c_common_signed_type (*restype_ptr);
2009
2010       if (TREE_TYPE (primop1) != *restype_ptr)
2011         {
2012           /* Convert primop1 to target type, but do not introduce
2013              additional overflow.  We know primop1 is an int_cst.  */
2014           tree tmp = build_int_cst_wide (*restype_ptr,
2015                                          TREE_INT_CST_LOW (primop1),
2016                                          TREE_INT_CST_HIGH (primop1));
2017
2018           primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2019                                     TREE_CONSTANT_OVERFLOW (primop1));
2020         }
2021       if (type != *restype_ptr)
2022         {
2023           minval = convert (*restype_ptr, minval);
2024           maxval = convert (*restype_ptr, maxval);
2025         }
2026
2027       if (unsignedp && unsignedp0)
2028         {
2029           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2030           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2031           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2032           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2033         }
2034       else
2035         {
2036           min_gt = INT_CST_LT (primop1, minval);
2037           max_gt = INT_CST_LT (primop1, maxval);
2038           min_lt = INT_CST_LT (minval, primop1);
2039           max_lt = INT_CST_LT (maxval, primop1);
2040         }
2041
2042       val = 0;
2043       /* This used to be a switch, but Genix compiler can't handle that.  */
2044       if (code == NE_EXPR)
2045         {
2046           if (max_lt || min_gt)
2047             val = truthvalue_true_node;
2048         }
2049       else if (code == EQ_EXPR)
2050         {
2051           if (max_lt || min_gt)
2052             val = truthvalue_false_node;
2053         }
2054       else if (code == LT_EXPR)
2055         {
2056           if (max_lt)
2057             val = truthvalue_true_node;
2058           if (!min_lt)
2059             val = truthvalue_false_node;
2060         }
2061       else if (code == GT_EXPR)
2062         {
2063           if (min_gt)
2064             val = truthvalue_true_node;
2065           if (!max_gt)
2066             val = truthvalue_false_node;
2067         }
2068       else if (code == LE_EXPR)
2069         {
2070           if (!max_gt)
2071             val = truthvalue_true_node;
2072           if (min_gt)
2073             val = truthvalue_false_node;
2074         }
2075       else if (code == GE_EXPR)
2076         {
2077           if (!min_lt)
2078             val = truthvalue_true_node;
2079           if (max_lt)
2080             val = truthvalue_false_node;
2081         }
2082
2083       /* If primop0 was sign-extended and unsigned comparison specd,
2084          we did a signed comparison above using the signed type bounds.
2085          But the comparison we output must be unsigned.
2086
2087          Also, for inequalities, VAL is no good; but if the signed
2088          comparison had *any* fixed result, it follows that the
2089          unsigned comparison just tests the sign in reverse
2090          (positive values are LE, negative ones GE).
2091          So we can generate an unsigned comparison
2092          against an extreme value of the signed type.  */
2093
2094       if (unsignedp && !unsignedp0)
2095         {
2096           if (val != 0)
2097             switch (code)
2098               {
2099               case LT_EXPR:
2100               case GE_EXPR:
2101                 primop1 = TYPE_MIN_VALUE (type);
2102                 val = 0;
2103                 break;
2104
2105               case LE_EXPR:
2106               case GT_EXPR:
2107                 primop1 = TYPE_MAX_VALUE (type);
2108                 val = 0;
2109                 break;
2110
2111               default:
2112                 break;
2113               }
2114           type = c_common_unsigned_type (type);
2115         }
2116
2117       if (TREE_CODE (primop0) != INTEGER_CST)
2118         {
2119           if (val == truthvalue_false_node)
2120             warning (0, "comparison is always false due to limited range of data type");
2121           if (val == truthvalue_true_node)
2122             warning (0, "comparison is always true due to limited range of data type");
2123         }
2124
2125       if (val != 0)
2126         {
2127           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2128           if (TREE_SIDE_EFFECTS (primop0))
2129             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2130           return val;
2131         }
2132
2133       /* Value is not predetermined, but do the comparison
2134          in the type of the operand that is not constant.
2135          TYPE is already properly set.  */
2136     }
2137   else if (real1 && real2
2138            && (TYPE_PRECISION (TREE_TYPE (primop0))
2139                == TYPE_PRECISION (TREE_TYPE (primop1))))
2140     type = TREE_TYPE (primop0);
2141
2142   /* If args' natural types are both narrower than nominal type
2143      and both extend in the same manner, compare them
2144      in the type of the wider arg.
2145      Otherwise must actually extend both to the nominal
2146      common type lest different ways of extending
2147      alter the result.
2148      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2149
2150   else if (unsignedp0 == unsignedp1 && real1 == real2
2151            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2152            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2153     {
2154       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2155       type = c_common_signed_or_unsigned_type (unsignedp0
2156                                                || TYPE_UNSIGNED (*restype_ptr),
2157                                                type);
2158       /* Make sure shorter operand is extended the right way
2159          to match the longer operand.  */
2160       primop0
2161         = convert (c_common_signed_or_unsigned_type (unsignedp0,
2162                                                      TREE_TYPE (primop0)),
2163                    primop0);
2164       primop1
2165         = convert (c_common_signed_or_unsigned_type (unsignedp1,
2166                                                      TREE_TYPE (primop1)),
2167                    primop1);
2168     }
2169   else
2170     {
2171       /* Here we must do the comparison on the nominal type
2172          using the args exactly as we received them.  */
2173       type = *restype_ptr;
2174       primop0 = op0;
2175       primop1 = op1;
2176
2177       if (!real1 && !real2 && integer_zerop (primop1)
2178           && TYPE_UNSIGNED (*restype_ptr))
2179         {
2180           tree value = 0;
2181           switch (code)
2182             {
2183             case GE_EXPR:
2184               /* All unsigned values are >= 0, so we warn if extra warnings
2185                  are requested.  However, if OP0 is a constant that is
2186                  >= 0, the signedness of the comparison isn't an issue,
2187                  so suppress the warning.  */
2188               if (extra_warnings && !in_system_header
2189                   && !(TREE_CODE (primop0) == INTEGER_CST
2190                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2191                                                    primop0))))
2192                 warning (0, "comparison of unsigned expression >= 0 is always true");
2193               value = truthvalue_true_node;
2194               break;
2195
2196             case LT_EXPR:
2197               if (extra_warnings && !in_system_header
2198                   && !(TREE_CODE (primop0) == INTEGER_CST
2199                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2200                                                    primop0))))
2201                 warning (0, "comparison of unsigned expression < 0 is always false");
2202               value = truthvalue_false_node;
2203               break;
2204
2205             default:
2206               break;
2207             }
2208
2209           if (value != 0)
2210             {
2211               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2212               if (TREE_SIDE_EFFECTS (primop0))
2213                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2214                                primop0, value);
2215               return value;
2216             }
2217         }
2218     }
2219
2220   *op0_ptr = convert (type, primop0);
2221   *op1_ptr = convert (type, primop1);
2222
2223   *restype_ptr = truthvalue_type_node;
2224
2225   return 0;
2226 }
2227 \f
2228 /* Return a tree for the sum or difference (RESULTCODE says which)
2229    of pointer PTROP and integer INTOP.  */
2230
2231 tree
2232 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2233 {
2234   tree size_exp;
2235
2236   /* The result is a pointer of the same type that is being added.  */
2237
2238   tree result_type = TREE_TYPE (ptrop);
2239
2240   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2241     {
2242       if (pedantic || warn_pointer_arith)
2243         pedwarn ("pointer of type %<void *%> used in arithmetic");
2244       size_exp = integer_one_node;
2245     }
2246   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2247     {
2248       if (pedantic || warn_pointer_arith)
2249         pedwarn ("pointer to a function used in arithmetic");
2250       size_exp = integer_one_node;
2251     }
2252   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2253     {
2254       if (pedantic || warn_pointer_arith)
2255         pedwarn ("pointer to member function used in arithmetic");
2256       size_exp = integer_one_node;
2257     }
2258   else
2259     size_exp = size_in_bytes (TREE_TYPE (result_type));
2260
2261   /* If what we are about to multiply by the size of the elements
2262      contains a constant term, apply distributive law
2263      and multiply that constant term separately.
2264      This helps produce common subexpressions.  */
2265
2266   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2267       && !TREE_CONSTANT (intop)
2268       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2269       && TREE_CONSTANT (size_exp)
2270       /* If the constant comes from pointer subtraction,
2271          skip this optimization--it would cause an error.  */
2272       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2273       /* If the constant is unsigned, and smaller than the pointer size,
2274          then we must skip this optimization.  This is because it could cause
2275          an overflow error if the constant is negative but INTOP is not.  */
2276       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2277           || (TYPE_PRECISION (TREE_TYPE (intop))
2278               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2279     {
2280       enum tree_code subcode = resultcode;
2281       tree int_type = TREE_TYPE (intop);
2282       if (TREE_CODE (intop) == MINUS_EXPR)
2283         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2284       /* Convert both subexpression types to the type of intop,
2285          because weird cases involving pointer arithmetic
2286          can result in a sum or difference with different type args.  */
2287       ptrop = build_binary_op (subcode, ptrop,
2288                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2289       intop = convert (int_type, TREE_OPERAND (intop, 0));
2290     }
2291
2292   /* Convert the integer argument to a type the same size as sizetype
2293      so the multiply won't overflow spuriously.  */
2294
2295   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2296       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2297     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2298                                              TYPE_UNSIGNED (sizetype)), intop);
2299
2300   /* Replace the integer argument with a suitable product by the object size.
2301      Do this multiplication as signed, then convert to the appropriate
2302      pointer type (actually unsigned integral).  */
2303
2304   intop = convert (result_type,
2305                    build_binary_op (MULT_EXPR, intop,
2306                                     convert (TREE_TYPE (intop), size_exp), 1));
2307
2308   /* Create the sum or difference.  */
2309   return fold_build2 (resultcode, result_type, ptrop, intop);
2310 }
2311 \f
2312 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2313    or for an `if' or `while' statement or ?..: exp.  It should already
2314    have been validated to be of suitable type; otherwise, a bad
2315    diagnostic may result.
2316
2317    This preparation consists of taking the ordinary
2318    representation of an expression expr and producing a valid tree
2319    boolean expression describing whether expr is nonzero.  We could
2320    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2321    but we optimize comparisons, &&, ||, and !.
2322
2323    The resulting type should always be `truthvalue_type_node'.  */
2324
2325 tree
2326 c_common_truthvalue_conversion (tree expr)
2327 {
2328   switch (TREE_CODE (expr))
2329     {
2330     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
2331     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
2332     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2333     case ORDERED_EXPR: case UNORDERED_EXPR:
2334       if (TREE_TYPE (expr) == truthvalue_type_node)
2335         return expr;
2336       return build2 (TREE_CODE (expr), truthvalue_type_node,
2337                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2338
2339     case TRUTH_ANDIF_EXPR:
2340     case TRUTH_ORIF_EXPR:
2341     case TRUTH_AND_EXPR:
2342     case TRUTH_OR_EXPR:
2343     case TRUTH_XOR_EXPR:
2344       if (TREE_TYPE (expr) == truthvalue_type_node)
2345         return expr;
2346       return build2 (TREE_CODE (expr), truthvalue_type_node,
2347                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2348                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2349
2350     case TRUTH_NOT_EXPR:
2351       if (TREE_TYPE (expr) == truthvalue_type_node)
2352         return expr;
2353       return build1 (TREE_CODE (expr), truthvalue_type_node,
2354                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2355
2356     case ERROR_MARK:
2357       return expr;
2358
2359     case INTEGER_CST:
2360       /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW.  */
2361       return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2362              ? truthvalue_true_node
2363              : truthvalue_false_node;
2364
2365     case REAL_CST:
2366       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2367              ? truthvalue_true_node
2368              : truthvalue_false_node;
2369
2370     case FUNCTION_DECL:
2371       expr = build_unary_op (ADDR_EXPR, expr, 0);
2372       /* Fall through.  */
2373
2374     case ADDR_EXPR:
2375       {
2376         if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2377             && !DECL_WEAK (TREE_OPERAND (expr, 0)))
2378           {
2379             /* Common Ada/Pascal programmer's mistake.  We always warn
2380                about this since it is so bad.  */
2381             warning (0, "the address of %qD, will always evaluate as %<true%>",
2382                      TREE_OPERAND (expr, 0));
2383             return truthvalue_true_node;
2384           }
2385
2386         /* If we are taking the address of an external decl, it might be
2387            zero if it is weak, so we cannot optimize.  */
2388         if (DECL_P (TREE_OPERAND (expr, 0))
2389             && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2390           break;
2391
2392         if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2393           return build2 (COMPOUND_EXPR, truthvalue_type_node,
2394                          TREE_OPERAND (expr, 0), truthvalue_true_node);
2395         else
2396           return truthvalue_true_node;
2397       }
2398
2399     case COMPLEX_EXPR:
2400       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2401                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2402                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2403                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2404                               0);
2405
2406     case NEGATE_EXPR:
2407     case ABS_EXPR:
2408     case FLOAT_EXPR:
2409       /* These don't change whether an object is nonzero or zero.  */
2410       return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2411
2412     case LROTATE_EXPR:
2413     case RROTATE_EXPR:
2414       /* These don't change whether an object is zero or nonzero, but
2415          we can't ignore them if their second arg has side-effects.  */
2416       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2417         return build2 (COMPOUND_EXPR, truthvalue_type_node,
2418                        TREE_OPERAND (expr, 1),
2419                        c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2420       else
2421         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2422
2423     case COND_EXPR:
2424       /* Distribute the conversion into the arms of a COND_EXPR.  */
2425       return fold_build3 (COND_EXPR, truthvalue_type_node,
2426                 TREE_OPERAND (expr, 0),
2427                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2428                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2429
2430     case CONVERT_EXPR:
2431       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2432          since that affects how `default_conversion' will behave.  */
2433       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2434           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2435         break;
2436       /* Fall through....  */
2437     case NOP_EXPR:
2438       /* If this is widening the argument, we can ignore it.  */
2439       if (TYPE_PRECISION (TREE_TYPE (expr))
2440           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2441         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2442       break;
2443
2444     case MINUS_EXPR:
2445       /* Perhaps reduce (x - y) != 0 to (x != y).  The expressions
2446          aren't guaranteed to the be same for modes that can represent
2447          infinity, since if x and y are both +infinity, or both
2448          -infinity, then x - y is not a number.
2449
2450          Note that this transformation is safe when x or y is NaN.
2451          (x - y) is then NaN, and both (x - y) != 0 and x != y will
2452          be false.  */
2453       if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2454         break;
2455       /* Fall through....  */
2456     case BIT_XOR_EXPR:
2457       /* This and MINUS_EXPR can be changed into a comparison of the
2458          two objects.  */
2459       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2460           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2461         return fold_build2 (NE_EXPR, truthvalue_type_node,
2462                             TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2463       return fold_build2 (NE_EXPR, truthvalue_type_node,
2464                           TREE_OPERAND (expr, 0),
2465                           fold_convert (TREE_TYPE (TREE_OPERAND (expr, 0)),
2466                                         TREE_OPERAND (expr, 1)));
2467
2468     case BIT_AND_EXPR:
2469       if (integer_onep (TREE_OPERAND (expr, 1))
2470           && TREE_TYPE (expr) != truthvalue_type_node)
2471         /* Using convert here would cause infinite recursion.  */
2472         return build1 (NOP_EXPR, truthvalue_type_node, expr);
2473       break;
2474
2475     case MODIFY_EXPR:
2476       if (!TREE_NO_WARNING (expr))
2477         warning (OPT_Wparentheses,
2478                  "suggest parentheses around assignment used as truth value");
2479       break;
2480
2481     default:
2482       break;
2483     }
2484
2485   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2486     {
2487       tree t = save_expr (expr);
2488       return (build_binary_op
2489               ((TREE_SIDE_EFFECTS (expr)
2490                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2491         c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2492         c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2493                0));
2494     }
2495
2496   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2497 }
2498 \f
2499 static void def_builtin_1  (enum built_in_function fncode,
2500                             const char *name,
2501                             enum built_in_class fnclass,
2502                             tree fntype, tree libtype,
2503                             bool both_p, bool fallback_p, bool nonansi_p,
2504                             tree fnattrs, bool implicit_p);
2505
2506 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2507    down to the element type of an array.  */
2508
2509 tree
2510 c_build_qualified_type (tree type, int type_quals)
2511 {
2512   if (type == error_mark_node)
2513     return type;
2514
2515   if (TREE_CODE (type) == ARRAY_TYPE)
2516     {
2517       tree t;
2518       tree element_type = c_build_qualified_type (TREE_TYPE (type),
2519                                                   type_quals);
2520
2521       /* See if we already have an identically qualified type.  */
2522       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2523         {
2524           if (TYPE_QUALS (strip_array_types (t)) == type_quals
2525               && TYPE_NAME (t) == TYPE_NAME (type)
2526               && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2527               && attribute_list_equal (TYPE_ATTRIBUTES (t),
2528                                        TYPE_ATTRIBUTES (type)))
2529             break;
2530         }
2531       if (!t)
2532         {
2533           t = build_variant_type_copy (type);
2534           TREE_TYPE (t) = element_type;
2535         }
2536       return t;
2537     }
2538
2539   /* A restrict-qualified pointer type must be a pointer to object or
2540      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2541      REFERENCE_TYPEs, which is appropriate for C++.  */
2542   if ((type_quals & TYPE_QUAL_RESTRICT)
2543       && (!POINTER_TYPE_P (type)
2544           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2545     {
2546       error ("invalid use of %<restrict%>");
2547       type_quals &= ~TYPE_QUAL_RESTRICT;
2548     }
2549
2550   return build_qualified_type (type, type_quals);
2551 }
2552
2553 /* Apply the TYPE_QUALS to the new DECL.  */
2554
2555 void
2556 c_apply_type_quals_to_decl (int type_quals, tree decl)
2557 {
2558   tree type = TREE_TYPE (decl);
2559
2560   if (type == error_mark_node)
2561     return;
2562
2563   if (((type_quals & TYPE_QUAL_CONST)
2564        || (type && TREE_CODE (type) == REFERENCE_TYPE))
2565       /* An object declared 'const' is only readonly after it is
2566          initialized.  We don't have any way of expressing this currently,
2567          so we need to be conservative and unset TREE_READONLY for types
2568          with constructors.  Otherwise aliasing code will ignore stores in
2569          an inline constructor.  */
2570       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2571     TREE_READONLY (decl) = 1;
2572   if (type_quals & TYPE_QUAL_VOLATILE)
2573     {
2574       TREE_SIDE_EFFECTS (decl) = 1;
2575       TREE_THIS_VOLATILE (decl) = 1;
2576     }
2577   if (type_quals & TYPE_QUAL_RESTRICT)
2578     {
2579       while (type && TREE_CODE (type) == ARRAY_TYPE)
2580         /* Allow 'restrict' on arrays of pointers.
2581            FIXME currently we just ignore it.  */
2582         type = TREE_TYPE (type);
2583       if (!type
2584           || !POINTER_TYPE_P (type)
2585           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2586         error ("invalid use of %<restrict%>");
2587       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2588         /* Indicate we need to make a unique alias set for this pointer.
2589            We can't do it here because it might be pointing to an
2590            incomplete type.  */
2591         DECL_POINTER_ALIAS_SET (decl) = -2;
2592     }
2593 }
2594
2595 /* Hash function for the problem of multiple type definitions in
2596    different files.  This must hash all types that will compare
2597    equal via comptypes to the same value.  In practice it hashes
2598    on some of the simple stuff and leaves the details to comptypes.  */
2599
2600 static hashval_t
2601 c_type_hash (const void *p)
2602 {
2603   int i = 0;
2604   int shift, size;
2605   tree t = (tree) p;
2606   tree t2;
2607   switch (TREE_CODE (t))
2608     {
2609     /* For pointers, hash on pointee type plus some swizzling.  */
2610     case POINTER_TYPE:
2611       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2612     /* Hash on number of elements and total size.  */
2613     case ENUMERAL_TYPE:
2614       shift = 3;
2615       t2 = TYPE_VALUES (t);
2616       break;
2617     case RECORD_TYPE:
2618       shift = 0;
2619       t2 = TYPE_FIELDS (t);
2620       break;
2621     case QUAL_UNION_TYPE:
2622       shift = 1;
2623       t2 = TYPE_FIELDS (t);
2624       break;
2625     case UNION_TYPE:
2626       shift = 2;
2627       t2 = TYPE_FIELDS (t);
2628       break;
2629     default:
2630       gcc_unreachable ();
2631     }
2632   for (; t2; t2 = TREE_CHAIN (t2))
2633     i++;
2634   size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2635   return ((size << 24) | (i << shift));
2636 }
2637
2638 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2639
2640 /* Return the typed-based alias set for T, which may be an expression
2641    or a type.  Return -1 if we don't do anything special.  */
2642
2643 HOST_WIDE_INT
2644 c_common_get_alias_set (tree t)
2645 {
2646   tree u;
2647   PTR *slot;
2648
2649   /* Permit type-punning when accessing a union, provided the access
2650      is directly through the union.  For example, this code does not
2651      permit taking the address of a union member and then storing
2652      through it.  Even the type-punning allowed here is a GCC
2653      extension, albeit a common and useful one; the C standard says
2654      that such accesses have implementation-defined behavior.  */
2655   for (u = t;
2656        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2657        u = TREE_OPERAND (u, 0))
2658     if (TREE_CODE (u) == COMPONENT_REF
2659         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2660       return 0;
2661
2662   /* That's all the expressions we handle specially.  */
2663   if (!TYPE_P (t))
2664     return -1;
2665
2666   /* The C standard guarantees that any object may be accessed via an
2667      lvalue that has character type.  */
2668   if (t == char_type_node
2669       || t == signed_char_type_node
2670       || t == unsigned_char_type_node)
2671     return 0;
2672
2673   /* If it has the may_alias attribute, it can alias anything.  */
2674   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2675     return 0;
2676
2677   /* The C standard specifically allows aliasing between signed and
2678      unsigned variants of the same type.  We treat the signed
2679      variant as canonical.  */
2680   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2681     {
2682       tree t1 = c_common_signed_type (t);
2683
2684       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2685       if (t1 != t)
2686         return get_alias_set (t1);
2687     }
2688   else if (POINTER_TYPE_P (t))
2689     {
2690       tree t1;
2691
2692       /* Unfortunately, there is no canonical form of a pointer type.
2693          In particular, if we have `typedef int I', then `int *', and
2694          `I *' are different types.  So, we have to pick a canonical
2695          representative.  We do this below.
2696
2697          Technically, this approach is actually more conservative that
2698          it needs to be.  In particular, `const int *' and `int *'
2699          should be in different alias sets, according to the C and C++
2700          standard, since their types are not the same, and so,
2701          technically, an `int **' and `const int **' cannot point at
2702          the same thing.
2703
2704          But, the standard is wrong.  In particular, this code is
2705          legal C++:
2706
2707             int *ip;
2708             int **ipp = &ip;
2709             const int* const* cipp = ipp;
2710
2711          And, it doesn't make sense for that to be legal unless you
2712          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2713          the pointed-to types.  This issue has been reported to the
2714          C++ committee.  */
2715       t1 = build_type_no_quals (t);
2716       if (t1 != t)
2717         return get_alias_set (t1);
2718     }
2719
2720   /* Handle the case of multiple type nodes referring to "the same" type,
2721      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
2722      C90 is handled.  (In C99 type compatibility is not transitive, which
2723      complicates things mightily. The alias set splay trees can theoretically
2724      represent this, but insertion is tricky when you consider all the
2725      different orders things might arrive in.) */
2726
2727   if (c_language != clk_c || flag_isoc99)
2728     return -1;
2729
2730   /* Save time if there's only one input file.  */
2731   if (num_in_fnames == 1)
2732     return -1;
2733
2734   /* Pointers need special handling if they point to any type that
2735      needs special handling (below).  */
2736   if (TREE_CODE (t) == POINTER_TYPE)
2737     {
2738       tree t2;
2739       /* Find bottom type under any nested POINTERs.  */
2740       for (t2 = TREE_TYPE (t);
2741      TREE_CODE (t2) == POINTER_TYPE;
2742      t2 = TREE_TYPE (t2))
2743   ;
2744       if (TREE_CODE (t2) != RECORD_TYPE
2745     && TREE_CODE (t2) != ENUMERAL_TYPE
2746     && TREE_CODE (t2) != QUAL_UNION_TYPE
2747     && TREE_CODE (t2) != UNION_TYPE)
2748   return -1;
2749       if (TYPE_SIZE (t2) == 0)
2750   return -1;
2751     }
2752   /* These are the only cases that need special handling.  */
2753   if (TREE_CODE (t) != RECORD_TYPE
2754       && TREE_CODE (t) != ENUMERAL_TYPE
2755       && TREE_CODE (t) != QUAL_UNION_TYPE
2756       && TREE_CODE (t) != UNION_TYPE
2757       && TREE_CODE (t) != POINTER_TYPE)
2758     return -1;
2759   /* Undefined? */
2760   if (TYPE_SIZE (t) == 0)
2761     return -1;
2762
2763   /* Look up t in hash table.  Only one of the compatible types within each
2764      alias set is recorded in the table.  */
2765   if (!type_hash_table)
2766     type_hash_table = htab_create_ggc (1021, c_type_hash,
2767             (htab_eq) lang_hooks.types_compatible_p,
2768             NULL);
2769   slot = htab_find_slot (type_hash_table, t, INSERT);
2770   if (*slot != NULL)
2771     {
2772       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2773       return TYPE_ALIAS_SET ((tree)*slot);
2774     }
2775   else
2776     /* Our caller will assign and record (in t) a new alias set; all we need
2777        to do is remember t in the hash table.  */
2778     *slot = t;
2779
2780   return -1;
2781 }
2782 \f
2783 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2784    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
2785    flag controls whether we should diagnose possibly ill-formed
2786    constructs or not.  */
2787
2788 tree
2789 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2790 {
2791   const char *op_name;
2792   tree value = NULL;
2793   enum tree_code type_code = TREE_CODE (type);
2794
2795   op_name = is_sizeof ? "sizeof" : "__alignof__";
2796
2797   if (type_code == FUNCTION_TYPE)
2798     {
2799       if (is_sizeof)
2800         {
2801           if (complain && (pedantic || warn_pointer_arith))
2802             pedwarn ("invalid application of %<sizeof%> to a function type");
2803           value = size_one_node;
2804         }
2805       else
2806         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2807     }
2808   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2809     {
2810       if (type_code == VOID_TYPE
2811           && complain && (pedantic || warn_pointer_arith))
2812         pedwarn ("invalid application of %qs to a void type", op_name);
2813       value = size_one_node;
2814     }
2815   else if (!COMPLETE_TYPE_P (type))
2816     {
2817       if (complain)
2818         error ("invalid application of %qs to incomplete type %qT ",
2819                op_name, type);
2820       value = size_zero_node;
2821     }
2822   else
2823     {
2824       if (is_sizeof)
2825         /* Convert in case a char is more than one unit.  */
2826         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2827                             size_int (TYPE_PRECISION (char_type_node)
2828                                       / BITS_PER_UNIT));
2829       else
2830         value = size_int (TYPE_ALIGN_UNIT (type));
2831     }
2832
2833   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2834      TYPE_IS_SIZETYPE means that certain things (like overflow) will
2835      never happen.  However, this node should really have type
2836      `size_t', which is just a typedef for an ordinary integer type.  */
2837   value = fold_build1 (NOP_EXPR, size_type_node, value);
2838   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
2839
2840   return value;
2841 }
2842
2843 /* Implement the __alignof keyword: Return the minimum required
2844    alignment of EXPR, measured in bytes.  For VAR_DECL's and
2845    FIELD_DECL's return DECL_ALIGN (which can be set from an
2846    "aligned" __attribute__ specification).  */
2847
2848 tree
2849 c_alignof_expr (tree expr)
2850 {
2851   tree t;
2852
2853   if (TREE_CODE (expr) == VAR_DECL)
2854     t = size_int (DECL_ALIGN_UNIT (expr));
2855
2856   else if (TREE_CODE (expr) == COMPONENT_REF
2857            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2858     {
2859       error ("%<__alignof%> applied to a bit-field");
2860       t = size_one_node;
2861     }
2862   else if (TREE_CODE (expr) == COMPONENT_REF
2863            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2864     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
2865
2866   else if (TREE_CODE (expr) == INDIRECT_REF)
2867     {
2868       tree t = TREE_OPERAND (expr, 0);
2869       tree best = t;
2870       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2871
2872       while (TREE_CODE (t) == NOP_EXPR
2873              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2874         {
2875           int thisalign;
2876
2877           t = TREE_OPERAND (t, 0);
2878           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2879           if (thisalign > bestalign)
2880             best = t, bestalign = thisalign;
2881         }
2882       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2883     }
2884   else
2885     return c_alignof (TREE_TYPE (expr));
2886
2887   return fold_build1 (NOP_EXPR, size_type_node, t);
2888 }
2889 \f
2890 /* Handle C and C++ default attributes.  */
2891
2892 enum built_in_attribute
2893 {
2894 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2895 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2896 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2897 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2898 #include "builtin-attrs.def"
2899 #undef DEF_ATTR_NULL_TREE
2900 #undef DEF_ATTR_INT
2901 #undef DEF_ATTR_IDENT
2902 #undef DEF_ATTR_TREE_LIST
2903   ATTR_LAST
2904 };
2905
2906 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2907
2908 static void c_init_attributes (void);
2909
2910 /* Build tree nodes and builtin functions common to both C and C++ language
2911    frontends.  */
2912
2913 void
2914 c_common_nodes_and_builtins (void)
2915 {
2916   enum builtin_type
2917   {
2918 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2919 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2920 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2921 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2922 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2923 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2924 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
2925 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
2926   NAME,
2927 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2928 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2929 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2930 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2931 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2932 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
2933   NAME,
2934 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2935 #include "builtin-types.def"
2936 #undef DEF_PRIMITIVE_TYPE
2937 #undef DEF_FUNCTION_TYPE_0
2938 #undef DEF_FUNCTION_TYPE_1
2939 #undef DEF_FUNCTION_TYPE_2
2940 #undef DEF_FUNCTION_TYPE_3
2941 #undef DEF_FUNCTION_TYPE_4
2942 #undef DEF_FUNCTION_TYPE_5
2943 #undef DEF_FUNCTION_TYPE_6
2944 #undef DEF_FUNCTION_TYPE_VAR_0
2945 #undef DEF_FUNCTION_TYPE_VAR_1
2946 #undef DEF_FUNCTION_TYPE_VAR_2
2947 #undef DEF_FUNCTION_TYPE_VAR_3
2948 #undef DEF_FUNCTION_TYPE_VAR_4
2949 #undef DEF_FUNCTION_TYPE_VAR_5
2950 #undef DEF_POINTER_TYPE
2951     BT_LAST
2952   };
2953
2954   typedef enum builtin_type builtin_type;
2955
2956   tree builtin_types[(int) BT_LAST + 1];
2957   int wchar_type_size;
2958   tree array_domain_type;
2959   tree va_list_ref_type_node;
2960   tree va_list_arg_type_node;
2961
2962   /* Define `int' and `char' first so that dbx will output them first.  */
2963   record_builtin_type (RID_INT, NULL, integer_type_node);
2964   record_builtin_type (RID_CHAR, "char", char_type_node);
2965
2966   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
2967      "unsigned long", "long long unsigned" and "unsigned short" were in C++
2968      but not C.  Are the conditionals here needed?  */
2969   if (c_dialect_cxx ())
2970     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2971   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2972   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2973   record_builtin_type (RID_MAX, "long unsigned int",
2974                        long_unsigned_type_node);
2975   if (c_dialect_cxx ())
2976     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2977   record_builtin_type (RID_MAX, "long long int",
2978                        long_long_integer_type_node);
2979   record_builtin_type (RID_MAX, "long long unsigned int",
2980                        long_long_unsigned_type_node);
2981   if (c_dialect_cxx ())
2982     record_builtin_type (RID_MAX, "long long unsigned",
2983                          long_long_unsigned_type_node);
2984   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2985   record_builtin_type (RID_MAX, "short unsigned int",
2986                        short_unsigned_type_node);
2987   if (c_dialect_cxx ())
2988     record_builtin_type (RID_MAX, "unsigned short",
2989                          short_unsigned_type_node);
2990
2991   /* Define both `signed char' and `unsigned char'.  */
2992   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2993   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2994
2995   /* These are types that c_common_type_for_size and
2996      c_common_type_for_mode use.  */
2997   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2998                                          intQI_type_node));
2999   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3000                                          intHI_type_node));
3001   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3002                                          intSI_type_node));
3003   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3004                                          intDI_type_node));
3005 #if HOST_BITS_PER_WIDE_INT >= 64
3006   if (targetm.scalar_mode_supported_p (TImode))
3007     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3008                                            get_identifier ("__int128_t"),
3009                                            intTI_type_node));
3010 #endif
3011   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3012                                          unsigned_intQI_type_node));
3013   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3014                                          unsigned_intHI_type_node));
3015   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3016                                          unsigned_intSI_type_node));
3017   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3018                                          unsigned_intDI_type_node));
3019 #if HOST_BITS_PER_WIDE_INT >= 64
3020   if (targetm.scalar_mode_supported_p (TImode))
3021     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3022                                            get_identifier ("__uint128_t"),
3023                                            unsigned_intTI_type_node));
3024 #endif
3025
3026   /* Create the widest literal types.  */
3027   widest_integer_literal_type_node
3028     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3029   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3030                                          widest_integer_literal_type_node));
3031
3032   widest_unsigned_literal_type_node
3033     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3034   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3035                                          widest_unsigned_literal_type_node));
3036
3037   /* `unsigned long' is the standard type for sizeof.
3038      Note that stddef.h uses `unsigned long',
3039      and this must agree, even if long and int are the same size.  */
3040   size_type_node =
3041     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3042   signed_size_type_node = c_common_signed_type (size_type_node);
3043   set_sizetype (size_type_node);
3044
3045   pid_type_node =
3046     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3047
3048   build_common_tree_nodes_2 (flag_short_double);
3049
3050   record_builtin_type (RID_FLOAT, NULL, float_type_node);
3051   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3052   record_builtin_type (RID_MAX, "long double", long_double_type_node);
3053
3054   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3055                                          get_identifier ("complex int"),
3056                                          complex_integer_type_node));
3057   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3058                                          get_identifier ("complex float"),
3059                                          complex_float_type_node));
3060   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3061                                          get_identifier ("complex double"),
3062                                          complex_double_type_node));
3063   lang_hooks.decls.pushdecl
3064     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3065                  complex_long_double_type_node));
3066
3067   if (c_dialect_cxx ())
3068     /* For C++, make fileptr_type_node a distinct void * type until
3069        FILE type is defined.  */
3070     fileptr_type_node = build_variant_type_copy (ptr_type_node);
3071
3072   record_builtin_type (RID_VOID, NULL, void_type_node);
3073
3074   /* This node must not be shared.  */
3075   void_zero_node = make_node (INTEGER_CST);
3076   TREE_TYPE (void_zero_node) = void_type_node;
3077
3078   void_list_node = build_void_list_node ();
3079
3080   /* Make a type to be the domain of a few array types
3081      whose domains don't really matter.
3082      200 is small enough that it always fits in size_t
3083      and large enough that it can hold most function names for the
3084      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3085   array_domain_type = build_index_type (size_int (200));
3086
3087   /* Make a type for arrays of characters.
3088      With luck nothing will ever really depend on the length of this
3089      array type.  */
3090   char_array_type_node
3091     = build_array_type (char_type_node, array_domain_type);
3092
3093   /* Likewise for arrays of ints.  */
3094   int_array_type_node
3095     = build_array_type (integer_type_node, array_domain_type);
3096
3097   string_type_node = build_pointer_type (char_type_node);
3098   const_string_type_node
3099     = build_pointer_type (build_qualified_type
3100                           (char_type_node, TYPE_QUAL_CONST));
3101
3102   /* This is special for C++ so functions can be overloaded.  */
3103   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3104   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3105   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3106   if (c_dialect_cxx ())
3107     {
3108       if (TYPE_UNSIGNED (wchar_type_node))
3109         wchar_type_node = make_unsigned_type (wchar_type_size);
3110       else
3111         wchar_type_node = make_signed_type (wchar_type_size);
3112       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3113     }
3114   else
3115     {
3116       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3117       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3118     }
3119
3120   /* This is for wide string constants.  */
3121   wchar_array_type_node
3122     = build_array_type (wchar_type_node, array_domain_type);
3123
3124   wint_type_node =
3125     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3126
3127   intmax_type_node =
3128     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3129   uintmax_type_node =
3130     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3131
3132   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3133   ptrdiff_type_node
3134     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3135   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3136
3137   lang_hooks.decls.pushdecl
3138     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3139                  va_list_type_node));
3140
3141   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3142     {
3143       va_list_arg_type_node = va_list_ref_type_node =
3144         build_pointer_type (TREE_TYPE (va_list_type_node));
3145     }
3146   else
3147     {
3148       va_list_arg_type_node = va_list_type_node;
3149       va_list_ref_type_node = build_reference_type (va_list_type_node);
3150     }
3151
3152 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3153   builtin_types[(int) ENUM] = VALUE;
3154 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
3155   builtin_types[(int) ENUM]                             \
3156     = build_function_type (builtin_types[(int) RETURN], \
3157                            void_list_node);
3158 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
3159   builtin_types[(int) ENUM]                                             \
3160     = build_function_type (builtin_types[(int) RETURN],                 \
3161                            tree_cons (NULL_TREE,                        \
3162                                       builtin_types[(int) ARG1],        \
3163                                       void_list_node));
3164 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
3165   builtin_types[(int) ENUM]                             \
3166     = build_function_type                               \
3167       (builtin_types[(int) RETURN],                     \
3168        tree_cons (NULL_TREE,                            \
3169                   builtin_types[(int) ARG1],            \
3170                   tree_cons (NULL_TREE,                 \
3171                              builtin_types[(int) ARG2], \
3172                              void_list_node)));
3173 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
3174   builtin_types[(int) ENUM]                                              \
3175     = build_function_type                                                \
3176       (builtin_types[(int) RETURN],                                      \
3177        tree_cons (NULL_TREE,                                             \
3178                   builtin_types[(int) ARG1],                             \
3179                   tree_cons (NULL_TREE,                                  \
3180                              builtin_types[(int) ARG2],                  \
3181                              tree_cons (NULL_TREE,                       \
3182                                         builtin_types[(int) ARG3],       \
3183                                         void_list_node))));
3184 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
3185   builtin_types[(int) ENUM]                                             \
3186     = build_function_type                                               \
3187       (builtin_types[(int) RETURN],                                     \
3188        tree_cons (NULL_TREE,                                            \
3189                   builtin_types[(int) ARG1],                            \
3190                   tree_cons (NULL_TREE,                                 \
3191                              builtin_types[(int) ARG2],                 \
3192                              tree_cons                                  \
3193                              (NULL_TREE,                                \
3194                               builtin_types[(int) ARG3],                \
3195                               tree_cons (NULL_TREE,                     \
3196                                          builtin_types[(int) ARG4],     \
3197                                          void_list_node)))));
3198 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3199   builtin_types[(int) ENUM]                                             \
3200     = build_function_type                                               \
3201       (builtin_types[(int) RETURN],                                     \
3202        tree_cons (NULL_TREE,                                            \
3203                   builtin_types[(int) ARG1],                            \
3204                   tree_cons (NULL_TREE,                                 \
3205                              builtin_types[(int) ARG2],                 \
3206                              tree_cons                                  \
3207                              (NULL_TREE,                                \
3208                               builtin_types[(int) ARG3],                \
3209                               tree_cons (NULL_TREE,                     \
3210                                          builtin_types[(int) ARG4],     \
3211                                          tree_cons (NULL_TREE,          \
3212                                               builtin_types[(int) ARG5],\
3213                                               void_list_node))))));
3214 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3215                             ARG6)                                       \
3216   builtin_types[(int) ENUM]                                             \
3217     = build_function_type                                               \
3218       (builtin_types[(int) RETURN],                                     \
3219        tree_cons (NULL_TREE,                                            \
3220                   builtin_types[(int) ARG1],                            \
3221                   tree_cons (NULL_TREE,                                 \
3222                              builtin_types[(int) ARG2],                 \
3223                              tree_cons                                  \
3224                              (NULL_TREE,                                \
3225                               builtin_types[(int) ARG3],                \
3226                               tree_cons                                 \
3227                               (NULL_TREE,                               \
3228                                builtin_types[(int) ARG4],               \
3229                                tree_cons (NULL_TREE,                    \
3230                                          builtin_types[(int) ARG5],     \
3231                                          tree_cons (NULL_TREE,          \
3232                                               builtin_types[(int) ARG6],\
3233                                               void_list_node)))))));
3234 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
3235   builtin_types[(int) ENUM]                                             \
3236     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3237 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
3238    builtin_types[(int) ENUM]                                             \
3239     = build_function_type (builtin_types[(int) RETURN],          \
3240                            tree_cons (NULL_TREE,                         \
3241                                       builtin_types[(int) ARG1],         \
3242                                       NULL_TREE));
3243
3244 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
3245    builtin_types[(int) ENUM]                                    \
3246     = build_function_type                                       \
3247       (builtin_types[(int) RETURN],                             \
3248        tree_cons (NULL_TREE,                                    \
3249                   builtin_types[(int) ARG1],                    \
3250                   tree_cons (NULL_TREE,                         \
3251                              builtin_types[(int) ARG2],         \
3252                              NULL_TREE)));
3253
3254 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3)         \
3255    builtin_types[(int) ENUM]                                            \
3256     = build_function_type                                               \
3257       (builtin_types[(int) RETURN],                                     \
3258        tree_cons (NULL_TREE,                                            \
3259                   builtin_types[(int) ARG1],                            \
3260                   tree_cons (NULL_TREE,                                 \
3261                              builtin_types[(int) ARG2],                 \
3262                              tree_cons (NULL_TREE,                      \
3263                                         builtin_types[(int) ARG3],      \
3264                                         NULL_TREE))));
3265
3266 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)   \
3267    builtin_types[(int) ENUM]                                            \
3268     = build_function_type                                               \
3269       (builtin_types[(int) RETURN],                                     \
3270        tree_cons (NULL_TREE,                                            \
3271                   builtin_types[(int) ARG1],                            \
3272                   tree_cons (NULL_TREE,                                 \
3273                              builtin_types[(int) ARG2],                 \
3274                              tree_cons (NULL_TREE,                      \
3275                                         builtin_types[(int) ARG3],      \
3276                                         tree_cons (NULL_TREE,           \
3277                                               builtin_types[(int) ARG4],\
3278                                               NULL_TREE)))));
3279
3280 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4,   \
3281                                 ARG5)                                   \
3282    builtin_types[(int) ENUM]                                            \
3283     = build_function_type                                               \
3284       (builtin_types[(int) RETURN],                                     \
3285        tree_cons (NULL_TREE,                                            \
3286                   builtin_types[(int) ARG1],                            \
3287                   tree_cons (NULL_TREE,                                 \
3288                              builtin_types[(int) ARG2],                 \
3289                              tree_cons                                  \
3290                              (NULL_TREE,                                \
3291                               builtin_types[(int) ARG3],                \
3292                               tree_cons (NULL_TREE,                     \
3293                                         builtin_types[(int) ARG4],      \
3294                                         tree_cons (NULL_TREE,           \
3295                                               builtin_types[(int) ARG5],\
3296                                               NULL_TREE))))));
3297
3298 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
3299   builtin_types[(int) ENUM]                             \
3300     = build_pointer_type (builtin_types[(int) TYPE]);
3301 #include "builtin-types.def"
3302 #undef DEF_PRIMITIVE_TYPE
3303 #undef DEF_FUNCTION_TYPE_1
3304 #undef DEF_FUNCTION_TYPE_2
3305 #undef DEF_FUNCTION_TYPE_3
3306 #undef DEF_FUNCTION_TYPE_4
3307 #undef DEF_FUNCTION_TYPE_5
3308 #undef DEF_FUNCTION_TYPE_6
3309 #undef DEF_FUNCTION_TYPE_VAR_0
3310 #undef DEF_FUNCTION_TYPE_VAR_1
3311 #undef DEF_FUNCTION_TYPE_VAR_2
3312 #undef DEF_FUNCTION_TYPE_VAR_3
3313 #undef DEF_FUNCTION_TYPE_VAR_4
3314 #undef DEF_FUNCTION_TYPE_VAR_5
3315 #undef DEF_POINTER_TYPE
3316   builtin_types[(int) BT_LAST] = NULL_TREE;
3317
3318   c_init_attributes ();
3319
3320 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3321                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
3322   if (NAME && COND)                                                     \
3323     def_builtin_1 (ENUM, NAME, CLASS,                                   \
3324                    builtin_types[(int) TYPE],                           \
3325                    builtin_types[(int) LIBTYPE],                        \
3326                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
3327                    built_in_attributes[(int) ATTRS], IMPLICIT);
3328 #include "builtins.def"
3329 #undef DEF_BUILTIN
3330
3331   build_common_builtin_nodes ();
3332
3333   targetm.init_builtins ();
3334   if (flag_mudflap)
3335     mudflap_init ();
3336
3337   main_identifier_node = get_identifier ("main");
3338
3339   /* Create the built-in __null node.  It is important that this is
3340      not shared.  */
3341   null_node = make_node (INTEGER_CST);
3342   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3343 }
3344
3345 /* Look up the function in built_in_decls that corresponds to DECL
3346    and set ASMSPEC as its user assembler name.  DECL must be a
3347    function decl that declares a builtin.  */
3348
3349 void
3350 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3351 {
3352   tree builtin;
3353   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3354               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3355               && asmspec != 0);
3356
3357   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3358   set_user_assembler_name (builtin, asmspec);
3359   if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3360     init_block_move_fn (asmspec);
3361   else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3362     init_block_clear_fn (asmspec);
3363 }
3364
3365 tree
3366 build_va_arg (tree expr, tree type)
3367 {
3368   return build1 (VA_ARG_EXPR, type, expr);
3369 }
3370
3371
3372 /* Linked list of disabled built-in functions.  */
3373
3374 typedef struct disabled_builtin
3375 {
3376   const char *name;
3377   struct disabled_builtin *next;
3378 } disabled_builtin;
3379 static disabled_builtin *disabled_builtins = NULL;
3380
3381 static bool builtin_function_disabled_p (const char *);
3382
3383 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
3384    begins with "__builtin_", give an error.  */
3385
3386 void
3387 disable_builtin_function (const char *name)
3388 {
3389   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3390     error ("cannot disable built-in function %qs", name);
3391   else
3392     {
3393       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3394       new_disabled_builtin->name = name;
3395       new_disabled_builtin->next = disabled_builtins;
3396       disabled_builtins = new_disabled_builtin;
3397     }
3398 }
3399
3400
3401 /* Return true if the built-in function NAME has been disabled, false
3402    otherwise.  */
3403
3404 static bool
3405 builtin_function_disabled_p (const char *name)
3406 {
3407   disabled_builtin *p;
3408   for (p = disabled_builtins; p != NULL; p = p->next)
3409     {
3410       if (strcmp (name, p->name) == 0)
3411         return true;
3412     }
3413   return false;
3414 }
3415
3416
3417 /* Worker for DEF_BUILTIN.
3418    Possibly define a builtin function with one or two names.
3419    Does not declare a non-__builtin_ function if flag_no_builtin, or if
3420    nonansi_p and flag_no_nonansi_builtin.  */
3421
3422 static void
3423 def_builtin_1 (enum built_in_function fncode,
3424                const char *name,
3425                enum built_in_class fnclass,
3426                tree fntype, tree libtype,
3427                bool both_p, bool fallback_p, bool nonansi_p,
3428                tree fnattrs, bool implicit_p)
3429 {
3430   tree decl;
3431   const char *libname;
3432
3433   gcc_assert ((!both_p && !fallback_p)
3434               || !strncmp (name, "__builtin_",