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