Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / gcc / c-common.c
CommitLineData
003757ed
MD
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
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-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
46cpp_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
184tree 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
189bool statement_code_p[MAX_TREE_CODES];
190\f
191/* Switches common to the C front ends. */
192
193/* Nonzero if prepreprocessing only. */
194
195int flag_preprocess_only;
196
197/* Nonzero means don't output line number information. */
198
199char 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
204char flag_no_output;
205
206/* Nonzero means dump macros in some fashion. */
207
208char flag_dump_macros;
209
210/* Nonzero means pass #include lines through to the output. */
211
212char 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
217const char *pch_file;
218
219/* Nonzero if an ISO standard was selected. It rejects macros in the
220 user's namespace. */
221int flag_iso;
222
223/* Nonzero if -undef was given. It suppresses target built-in macros
224 and assertions. */
225int flag_undef;
226
227/* Nonzero means don't recognize the non-ANSI builtin functions. */
228
229int flag_no_builtin;
230
231/* Nonzero means don't recognize the non-ANSI builtin functions.
232 -ansi sets this. */
233
234int flag_no_nonansi_builtin;
235
236/* Nonzero means give `double' the same size as `float'. */
237
238int flag_short_double;
239
240/* Nonzero means give `wchar_t' the same size as `short'. */
241
242int flag_short_wchar;
243
244/* Nonzero means allow Microsoft extensions without warnings or errors. */
245int flag_ms_extensions;
246
247/* Nonzero means don't recognize the keyword `asm'. */
248
249int flag_no_asm;
250
251/* Nonzero means give string constants the type `const char *', as mandated
252 by the standard. */
253
254int flag_const_strings;
255
256/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
257
258int flag_signed_bitfields = 1;
259int 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
264int warn_cast_qual;
265
266/* Warn about functions which might be candidates for format attributes. */
267
268int warn_missing_format_attribute;
269
270/* Nonzero means warn about sizeof(function) or addition/subtraction
271 of function pointers. */
272
273int warn_pointer_arith;
274
275/* Nonzero means warn for any global function def
276 without separate previous prototype decl. */
277
278int warn_missing_prototypes;
279
280/* Warn if adding () is suggested. */
281
282int warn_parentheses;
283
284/* Warn if initializer is not completely bracketed. */
285
286int 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
292int warn_sign_compare = -1;
293
294/* Nonzero means warn about usage of long long when `-pedantic'. */
295
296int warn_long_long = 1;
297
298/* Nonzero means warn about deprecated conversion from string constant to
299 `char *'. */
300
301int warn_write_strings;
302
303/* Nonzero means warn about multiple (redundant) decls for the same single
304 variable or function. */
305
306int warn_redundant_decls;
307
308/* Warn about testing equality of floating point numbers. */
309
310int warn_float_equal;
311
312/* Warn about a subscript that has type char. */
313
314int warn_char_subscripts;
315
316/* Warn if a type conversion is done that might have confusing results. */
317
318int warn_conversion;
319
320/* Warn about #pragma directives that are not recognized. */
321
322int 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
327int warn_format;
328
329/* Warn about Y2K problems with strftime formats. */
330
331int warn_format_y2k;
332
333/* Warn about excess arguments to formats. */
334
335int warn_format_extra_args;
336
337/* Warn about zero-length formats. */
338
339int warn_format_zero_length;
340
341/* Warn about non-literal format arguments. */
342
343int warn_format_nonliteral;
344
345/* Warn about possible security problems with calls to format functions. */
346
347int 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. */
352int flag_nil_receivers = 1;
353
354/* Nonzero means that we will allow new ObjC exception syntax (@throw,
355 @try, etc.) in source code. */
356int 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. */
361int 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. */
366int 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
374int mesg_implicit_function_declaration = -1;
375
376/* Nonzero means allow type mismatches in conditional expressions;
377 just make their values `void'. */
378
379int flag_cond_mismatch;
380
381/* Nonzero means enable C89 Amendment 1 features. */
382
383int flag_isoc94;
384
385/* Nonzero means use the ISO C99 dialect of C. */
386
387int flag_isoc99;
388
389/* Nonzero means that we have builtin functions, and main is an int. */
390
391int 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
397int warn_bad_function_cast;
398
399/* Warn about traditional constructs whose meanings changed in ANSI C. */
400
401int warn_traditional;
402
403/* Nonzero means warn for a declaration found after a statement. */
404
405int warn_declaration_after_statement;
406
407/* Nonzero means warn for non-prototype function decls
408 or non-prototyped defs without previous prototype. */
409
410int warn_strict_prototypes;
411
412/* Nonzero means warn for any global function def
413 without separate previous decl. */
414
415int 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
423int warn_nested_externs;
424
425/* Warn if main is suspicious. */
426
427int warn_main;
428
429/* Nonzero means warn about possible violations of sequence point rules. */
430
431int 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
436int warn_init_self;
437
438/* Nonzero means to warn about compile-time division by zero. */
439int warn_div_by_zero = 1;
440
441/* Nonzero means warn about use of implicit int. */
442
443int warn_implicit_int;
444
445/* Warn about NULL being passed to argument slots marked as requiring
446 non-NULL. */
447
448int warn_nonnull;
449
450/* Warn about old-style parameter declaration. */
451
452int 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
461int flag_gen_declaration;
462
463/* Generate code for GNU or NeXT runtime environment. */
464
465#ifdef NEXT_OBJC_RUNTIME
466int flag_next_runtime = 1;
467#else
468int 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
475int print_struct_values;
476
477/* ???. Undocumented. */
478
479const 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
485int 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
492int 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
498int warn_protocol = 1;
499
500
501/* C++ language option variables. */
502
503
504/* Nonzero means don't recognize any extension keywords. */
505
506int flag_no_gnu_keywords;
507
508/* Nonzero means do emit exported implementations of functions even if
509 they can be inlined. */
510
511int flag_implement_inlines = 1;
512
513/* Nonzero means that implicit instantiations will be emitted if needed. */
514
515int 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
521int flag_implicit_inline_templates = 1;
522
523/* Nonzero means generate separate instantiation control files and
524 juggle them at link time. */
525
526int flag_use_repository;
527
528/* Nonzero if we want to issue diagnostics that the standard says are not
529 required. */
530
531int flag_optional_diags = 1;
532
533/* Nonzero means we should attempt to elide constructors when possible. */
534
535int flag_elide_constructors = 1;
536
537/* Nonzero means that member functions defined in class scope are
538 inline by default. */
539
540int flag_default_inline = 1;
541
542/* Controls whether compiler generates 'type descriptor' that give
543 run-time type information. */
544
545int 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
552int flag_conserve_space;
553
554/* Nonzero if we want to obey access control semantics. */
555
556int 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
561int 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
570int 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
576int 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
583int 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
588int 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
593int 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
600int flag_enforce_eh_specs = 1;
601
602/* Nonzero means warn about things that will change when compiling
603 with an ABI-compliant compiler. */
604
605int warn_abi = 0;
606
607/* Nonzero means warn about invalid uses of offsetof. */
608
609int warn_invalid_offsetof = 1;
610
611/* Nonzero means warn about implicit declarations. */
612
613int warn_implicit = 1;
614
615/* Nonzero means warn when all ctors or dtors are private, and the class
616 has no friends. */
617
618int 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
624int 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
629int warn_nonvdtor;
630
631/* Nonzero means warn when the compiler will reorder code. */
632
633int warn_reorder;
634
635/* Nonzero means warn when synthesis behavior differs from Cfront's. */
636
637int warn_synth;
638
639/* Nonzero means warn when we convert a pointer to member function
640 into a pointer to (void or function). */
641
642int warn_pmf2ptr = 1;
643
644/* Nonzero means warn about violation of some Effective C++ style rules. */
645
646int 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
651int warn_sign_promo;
652
653/* Nonzero means warn when an old-style cast is used. */
654
655int warn_old_style_cast;
656
657/* Nonzero means warn when non-templatized friend functions are
658 declared within a template */
659
660int warn_nontemplate_friend = 1;
661
662/* Nonzero means complain about deprecated features. */
663
664int 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
670int 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. */
676tree *ridpointers;
677
678tree (*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. */
682void (*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. */
686int skip_evaluation;
687
688/* Information about how a function name is generated. */
689struct 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
698const 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
709static 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. */
716typedef struct
717{
718 int compstmt_count;
719 location_t locus;
720 int needs_warning;
721 tree if_stmt;
722} if_elt;
723
724static if_elt *if_stack;
725
726/* Amount of space in the if statement stack. */
727static int if_stack_space = 0;
728
729/* Stack pointer. */
730static int if_stack_pointer = 0;
731
732static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
733static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
734static tree handle_common_attribute (tree *, tree, tree, int, bool *);
735static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
736static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
737static tree handle_always_inline_attribute (tree *, tree, tree, int,
738 bool *);
739static tree handle_used_attribute (tree *, tree, tree, int, bool *);
740static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
741static tree handle_const_attribute (tree *, tree, tree, int, bool *);
742static tree handle_transparent_union_attribute (tree *, tree, tree,
743 int, bool *);
744static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
745static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
746static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
747static tree handle_section_attribute (tree *, tree, tree, int, bool *);
748static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
749static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
750static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
751static tree handle_visibility_attribute (tree *, tree, tree, int,
752 bool *);
753static tree handle_tls_model_attribute (tree *, tree, tree, int,
754 bool *);
755static tree handle_no_instrument_function_attribute (tree *, tree,
756 tree, int, bool *);
757static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
758static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
759 bool *);
760static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
761static tree handle_deprecated_attribute (tree *, tree, tree, int,
762 bool *);
763static tree handle_vector_size_attribute (tree *, tree, tree, int,
764 bool *);
765static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
766static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
767static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
768static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
769 bool *);
003757ed
MD
770
771static void check_function_nonnull (tree, tree);
772static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
773static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
774static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
775static int resort_field_decl_cmp (const void *, const void *);
776
777/* Table of machine-independent attributes common to all C-like languages. */
778const 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
854const 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
873void
874c_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
901void
902c_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
911void
912c_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
924void
925c_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
944void
945c_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
959tree
960c_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
975tree
976c_begin_while_stmt (void)
977{
978 tree r;
979 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
980 return r;
981}
982
983void
984c_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
991void
992start_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
1021void
1022finish_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
1076const char *
1077fname_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
1101tree
1102fname_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)
1c1138ce 1140 pedwarn ("'%D' is not defined outside of function scope", decl);
003757ed
MD
1141
1142 return decl;
1143}
1144
1145/* Given a STRING_CST, give it a suitable array-of-chars data type. */
1146
1147tree
1148fix_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
1193void
1194constant_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
1210void
1211overflow_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
1244void
1245unsigned_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
1266static int
1267constant_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
1378ea41
SS
1276/* Nonzero if vector types T1 and T2 can be converted to each other
1277 without an explicit cast. */
1278int
1279vector_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
003757ed
MD
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
1292tree
1293convert_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. */
1328struct 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. */
1336struct 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. */
1346static struct obstack tlist_obstack;
1347static char *tlist_firstobj = 0;
1348
1349/* Keep track of the identifiers we've warned about, so we can avoid duplicate
1350 warnings. */
1351static struct tlist *warned_ids;
1352/* SAVE_EXPRs need special treatment. We process them only once and then
1353 cache the results. */
1354static struct tlist_cache *save_expr_cache;
1355
1356static void add_tlist (struct tlist **, struct tlist *, tree, int);
1357static void merge_tlist (struct tlist **, struct tlist *, int);
1358static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1359static int warning_candidate_p (tree);
1360static void warn_for_collisions (struct tlist *);
1361static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1362static struct tlist *new_tlist (struct tlist *, tree, tree);
1363static void verify_sequence_points (tree);
1364
1365/* Create a new struct tlist and fill in its fields. */
1366static struct tlist *
1367new_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
1380static void
1381add_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
1400static void
1401merge_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
1435static void
1436warn_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
1463static void
1464warn_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. */
1477static int
1478warning_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
1508static void
1509verify_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
1703static void
1704verify_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
1721tree
1722c_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
1745tree
1746check_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
1784tree
1785c_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. */
1824static 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
1830tree
1831c_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. */
1931tree
1932c_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
1965tree
1966c_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
2000tree
2001c_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
2045void
2046c_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
2063unsigned int
2064min_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
2091void
2092binary_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
2167tree
2168shorten_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
2495tree
2496pointer_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
2596tree
2597c_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
2771static 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
2778tree
2779c_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
2805void
2806c_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
2848HOST_WIDE_INT
2849c_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. */
2931tree
2932c_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
2992tree
2993c_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
3036enum 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
3050static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3051
3052static void c_init_attributes (void);
3053
3054/* Build tree nodes and builtin functions common to both C and C++ language
3055 frontends. */
3056
3057void
3058c_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
3470tree
3471build_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
3479typedef struct disabled_builtin
3480{
3481 const char *name;
3482 struct disabled_builtin *next;
3483} disabled_builtin;
3484static disabled_builtin *disabled_builtins = NULL;
3485
3486static 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
3491void
3492disable_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
3509static bool
3510builtin_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
3537static tree
3538builtin_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
3560bool
3561c_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
3590int
3591self_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
3616tree
3617strip_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. */
3626tree
3627strip_pointer_operator (tree t)
3628{
3629 while (POINTER_TYPE_P (t))
3630 t = TREE_TYPE (t);
3631 return t;
3632}
3633
3634static 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
3645static tree
3646expand_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
3716tree
3717expand_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
3793tree
3794walk_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