OSDN Git Service

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