Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / gcc-4.4 / gcc / c-common.c
CommitLineData
c251ad9e
SS
1/* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "intl.h"
27#include "tree.h"
28#include "flags.h"
29#include "output.h"
30#include "c-pragma.h"
31#include "rtl.h"
32#include "ggc.h"
33#include "varray.h"
34#include "expr.h"
35#include "c-common.h"
36#include "diagnostic.h"
37#include "tm_p.h"
38#include "obstack.h"
39#include "cpplib.h"
40#include "target.h"
41#include "langhooks.h"
42#include "tree-inline.h"
43#include "c-tree.h"
44#include "toplev.h"
45#include "tree-iterator.h"
46#include "hashtab.h"
47#include "tree-mudflap.h"
48#include "opts.h"
49#include "real.h"
50#include "cgraph.h"
51#include "target-def.h"
52#include "gimple.h"
53#include "fixed-value.h"
54#include "libfuncs.h"
55
56cpp_reader *parse_in; /* Declared in c-pragma.h. */
57
58/* We let tm.h override the types used here, to handle trivial differences
59 such as the choice of unsigned int or long unsigned int for size_t.
60 When machines start needing nontrivial differences in the size type,
61 it would be best to do something here to figure out automatically
62 from other information what type to use. */
63
64#ifndef SIZE_TYPE
65#define SIZE_TYPE "long unsigned int"
66#endif
67
68#ifndef PID_TYPE
69#define PID_TYPE "int"
70#endif
71
72#ifndef CHAR16_TYPE
73#define CHAR16_TYPE "short unsigned int"
74#endif
75
76#ifndef CHAR32_TYPE
77#define CHAR32_TYPE "unsigned int"
78#endif
79
80#ifndef WCHAR_TYPE
81#define WCHAR_TYPE "int"
82#endif
83
84/* WCHAR_TYPE gets overridden by -fshort-wchar. */
85#define MODIFIED_WCHAR_TYPE \
86 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
87
88#ifndef PTRDIFF_TYPE
89#define PTRDIFF_TYPE "long int"
90#endif
91
92#ifndef WINT_TYPE
93#define WINT_TYPE "unsigned int"
94#endif
95
96#ifndef INTMAX_TYPE
97#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
98 ? "int" \
99 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
100 ? "long int" \
101 : "long long int"))
102#endif
103
104#ifndef UINTMAX_TYPE
105#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
106 ? "unsigned int" \
107 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
108 ? "long unsigned int" \
109 : "long long unsigned int"))
110#endif
111
112/* The following symbols are subsumed in the c_global_trees array, and
113 listed here individually for documentation purposes.
114
115 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
116
117 tree short_integer_type_node;
118 tree long_integer_type_node;
119 tree long_long_integer_type_node;
120
121 tree short_unsigned_type_node;
122 tree long_unsigned_type_node;
123 tree long_long_unsigned_type_node;
124
125 tree truthvalue_type_node;
126 tree truthvalue_false_node;
127 tree truthvalue_true_node;
128
129 tree ptrdiff_type_node;
130
131 tree unsigned_char_type_node;
132 tree signed_char_type_node;
133 tree wchar_type_node;
134 tree signed_wchar_type_node;
135 tree unsigned_wchar_type_node;
136
137 tree char16_type_node;
138 tree char32_type_node;
139
140 tree float_type_node;
141 tree double_type_node;
142 tree long_double_type_node;
143
144 tree complex_integer_type_node;
145 tree complex_float_type_node;
146 tree complex_double_type_node;
147 tree complex_long_double_type_node;
148
149 tree dfloat32_type_node;
150 tree dfloat64_type_node;
151 tree_dfloat128_type_node;
152
153 tree intQI_type_node;
154 tree intHI_type_node;
155 tree intSI_type_node;
156 tree intDI_type_node;
157 tree intTI_type_node;
158
159 tree unsigned_intQI_type_node;
160 tree unsigned_intHI_type_node;
161 tree unsigned_intSI_type_node;
162 tree unsigned_intDI_type_node;
163 tree unsigned_intTI_type_node;
164
165 tree widest_integer_literal_type_node;
166 tree widest_unsigned_literal_type_node;
167
168 Nodes for types `void *' and `const void *'.
169
170 tree ptr_type_node, const_ptr_type_node;
171
172 Nodes for types `char *' and `const char *'.
173
174 tree string_type_node, const_string_type_node;
175
176 Type `char[SOMENUMBER]'.
177 Used when an array of char is needed and the size is irrelevant.
178
179 tree char_array_type_node;
180
181 Type `int[SOMENUMBER]' or something like it.
182 Used when an array of int needed and the size is irrelevant.
183
184 tree int_array_type_node;
185
186 Type `wchar_t[SOMENUMBER]' or something like it.
187 Used when a wide string literal is created.
188
189 tree wchar_array_type_node;
190
191 Type `char16_t[SOMENUMBER]' or something like it.
192 Used when a UTF-16 string literal is created.
193
194 tree char16_array_type_node;
195
196 Type `char32_t[SOMENUMBER]' or something like it.
197 Used when a UTF-32 string literal is created.
198
199 tree char32_array_type_node;
200
201 Type `int ()' -- used for implicit declaration of functions.
202
203 tree default_function_type;
204
205 A VOID_TYPE node, packaged in a TREE_LIST.
206
207 tree void_list_node;
208
209 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
210 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
211 VAR_DECLS, but C++ does.)
212
213 tree function_name_decl_node;
214 tree pretty_function_name_decl_node;
215 tree c99_function_name_decl_node;
216
217 Stack of nested function name VAR_DECLs.
218
219 tree saved_function_name_decls;
220
221*/
222
223tree c_global_trees[CTI_MAX];
224\f
225/* Switches common to the C front ends. */
226
227/* Nonzero if preprocessing only. */
228
229int flag_preprocess_only;
230
231/* Nonzero means don't output line number information. */
232
233char flag_no_line_commands;
234
235/* Nonzero causes -E output not to be done, but directives such as
236 #define that have side effects are still obeyed. */
237
238char flag_no_output;
239
240/* Nonzero means dump macros in some fashion. */
241
242char flag_dump_macros;
243
244/* Nonzero means pass #include lines through to the output. */
245
246char flag_dump_includes;
247
248/* Nonzero means process PCH files while preprocessing. */
249
250bool flag_pch_preprocess;
251
252/* The file name to which we should write a precompiled header, or
253 NULL if no header will be written in this compile. */
254
255const char *pch_file;
256
257/* Nonzero if an ISO standard was selected. It rejects macros in the
258 user's namespace. */
259int flag_iso;
260
261/* Nonzero if -undef was given. It suppresses target built-in macros
262 and assertions. */
263int flag_undef;
264
265/* Nonzero means don't recognize the non-ANSI builtin functions. */
266
267int flag_no_builtin;
268
269/* Nonzero means don't recognize the non-ANSI builtin functions.
270 -ansi sets this. */
271
272int flag_no_nonansi_builtin;
273
274/* Nonzero means give `double' the same size as `float'. */
275
276int flag_short_double;
277
278/* Nonzero means give `wchar_t' the same size as `short'. */
279
280int flag_short_wchar;
281
282/* Nonzero means allow implicit conversions between vectors with
283 differing numbers of subparts and/or differing element types. */
284int flag_lax_vector_conversions;
285
286/* Nonzero means allow Microsoft extensions without warnings or errors. */
287int flag_ms_extensions;
288
289/* Nonzero means don't recognize the keyword `asm'. */
290
291int flag_no_asm;
292
293/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
294
295int flag_signed_bitfields = 1;
296
297/* Warn about #pragma directives that are not recognized. */
298
299int warn_unknown_pragmas; /* Tri state variable. */
300
301/* Warn about format/argument anomalies in calls to formatted I/O functions
302 (*printf, *scanf, strftime, strfmon, etc.). */
303
304int warn_format;
305
306/* Warn about using __null (as NULL in C++) as sentinel. For code compiled
307 with GCC this doesn't matter as __null is guaranteed to have the right
308 size. */
309
310int warn_strict_null_sentinel;
311
312/* Zero means that faster, ...NonNil variants of objc_msgSend...
313 calls will be used in ObjC; passing nil receivers to such calls
314 will most likely result in crashes. */
315int flag_nil_receivers = 1;
316
317/* Nonzero means that code generation will be altered to support
318 "zero-link" execution. This currently affects ObjC only, but may
319 affect other languages in the future. */
320int flag_zero_link = 0;
321
322/* Nonzero means emit an '__OBJC, __image_info' for the current translation
323 unit. It will inform the ObjC runtime that class definition(s) herein
324 contained are to replace one(s) previously loaded. */
325int flag_replace_objc_classes = 0;
326
327/* C/ObjC language option variables. */
328
329
330/* Nonzero means allow type mismatches in conditional expressions;
331 just make their values `void'. */
332
333int flag_cond_mismatch;
334
335/* Nonzero means enable C89 Amendment 1 features. */
336
337int flag_isoc94;
338
339/* Nonzero means use the ISO C99 dialect of C. */
340
341int flag_isoc99;
342
343/* Nonzero means that we have builtin functions, and main is an int. */
344
345int flag_hosted = 1;
346
347
348/* ObjC language option variables. */
349
350
351/* Open and close the file for outputting class declarations, if
352 requested (ObjC). */
353
354int flag_gen_declaration;
355
356/* Tells the compiler that this is a special run. Do not perform any
357 compiling, instead we are to test some platform dependent features
358 and output a C header file with appropriate definitions. */
359
360int print_struct_values;
361
362/* Tells the compiler what is the constant string class for ObjC. */
363
364const char *constant_string_class_name;
365
366
367/* C++ language option variables. */
368
369
370/* Nonzero means don't recognize any extension keywords. */
371
372int flag_no_gnu_keywords;
373
374/* Nonzero means do emit exported implementations of functions even if
375 they can be inlined. */
376
377int flag_implement_inlines = 1;
378
379/* Nonzero means that implicit instantiations will be emitted if needed. */
380
381int flag_implicit_templates = 1;
382
383/* Nonzero means that implicit instantiations of inline templates will be
384 emitted if needed, even if instantiations of non-inline templates
385 aren't. */
386
387int flag_implicit_inline_templates = 1;
388
389/* Nonzero means generate separate instantiation control files and
390 juggle them at link time. */
391
392int flag_use_repository;
393
394/* Nonzero if we want to issue diagnostics that the standard says are not
395 required. */
396
397int flag_optional_diags = 1;
398
399/* Nonzero means we should attempt to elide constructors when possible. */
400
401int flag_elide_constructors = 1;
402
403/* Nonzero means that member functions defined in class scope are
404 inline by default. */
405
406int flag_default_inline = 1;
407
408/* Controls whether compiler generates 'type descriptor' that give
409 run-time type information. */
410
411int flag_rtti = 1;
412
413/* Nonzero if we want to conserve space in the .o files. We do this
414 by putting uninitialized data and runtime initialized data into
415 .common instead of .data at the expense of not flagging multiple
416 definitions. */
417
418int flag_conserve_space;
419
420/* Nonzero if we want to obey access control semantics. */
421
422int flag_access_control = 1;
423
424/* Nonzero if we want to check the return value of new and avoid calling
425 constructors if it is a null pointer. */
426
427int flag_check_new;
428
429/* The C++ dialect being used. C++98 is the default. */
430
431enum cxx_dialect cxx_dialect = cxx98;
432
433/* Nonzero if we want the new ISO rules for pushing a new scope for `for'
434 initialization variables.
435 0: Old rules, set by -fno-for-scope.
436 2: New ISO rules, set by -ffor-scope.
437 1: Try to implement new ISO rules, but with backup compatibility
438 (and warnings). This is the default, for now. */
439
440int flag_new_for_scope = 1;
441
442/* Nonzero if we want to emit defined symbols with common-like linkage as
443 weak symbols where possible, in order to conform to C++ semantics.
444 Otherwise, emit them as local symbols. */
445
446int flag_weak = 1;
447
448/* 0 means we want the preprocessor to not emit line directives for
449 the current working directory. 1 means we want it to do it. -1
450 means we should decide depending on whether debugging information
451 is being emitted or not. */
452
453int flag_working_directory = -1;
454
455/* Nonzero to use __cxa_atexit, rather than atexit, to register
456 destructors for local statics and global objects. '2' means it has been
457 set nonzero as a default, not by a command-line flag. */
458
459int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
460
461/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
462 code. '2' means it has not been set explicitly on the command line. */
463
464int flag_use_cxa_get_exception_ptr = 2;
465
466/* Nonzero means to implement standard semantics for exception
467 specifications, calling unexpected if an exception is thrown that
468 doesn't match the specification. Zero means to treat them as
469 assertions and optimize accordingly, but not check them. */
470
471int flag_enforce_eh_specs = 1;
472
473/* Nonzero means to generate thread-safe code for initializing local
474 statics. */
475
476int flag_threadsafe_statics = 1;
477
478/* Nonzero means warn about implicit declarations. */
479
480int warn_implicit = 1;
481
482/* Maximum template instantiation depth. This limit is rather
483 arbitrary, but it exists to limit the time it takes to notice
484 infinite template instantiations. */
485
486int max_tinst_depth = 500;
487
488
489
490/* The elements of `ridpointers' are identifier nodes for the reserved
491 type names and storage classes. It is indexed by a RID_... value. */
492tree *ridpointers;
493
494tree (*make_fname_decl) (tree, int);
495
496/* Nonzero means the expression being parsed will never be evaluated.
497 This is a count, since unevaluated expressions can nest. */
498int skip_evaluation;
499
500/* Information about how a function name is generated. */
501struct fname_var_t
502{
503 tree *const decl; /* pointer to the VAR_DECL. */
504 const unsigned rid; /* RID number for the identifier. */
505 const int pretty; /* How pretty is it? */
506};
507
508/* The three ways of getting then name of the current function. */
509
510const struct fname_var_t fname_vars[] =
511{
512 /* C99 compliant __func__, must be first. */
513 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
514 /* GCC __FUNCTION__ compliant. */
515 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
516 /* GCC __PRETTY_FUNCTION__ compliant. */
517 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
518 {NULL, 0, 0},
519};
520
521static tree check_case_value (tree);
522static bool check_case_bounds (tree, tree, tree *, tree *);
523
524static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
525static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
526static tree handle_common_attribute (tree *, tree, tree, int, bool *);
527static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
528static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
529static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
530static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
531static tree handle_always_inline_attribute (tree *, tree, tree, int,
532 bool *);
533static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
534static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
535static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
536static tree handle_error_attribute (tree *, tree, tree, int, bool *);
537static tree handle_used_attribute (tree *, tree, tree, int, bool *);
538static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
539static tree handle_externally_visible_attribute (tree *, tree, tree, int,
540 bool *);
541static tree handle_const_attribute (tree *, tree, tree, int, bool *);
542static tree handle_transparent_union_attribute (tree *, tree, tree,
543 int, bool *);
544static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
545static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
546static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
547static tree handle_section_attribute (tree *, tree, tree, int, bool *);
548static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
549static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
550static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
551static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
552static tree handle_visibility_attribute (tree *, tree, tree, int,
553 bool *);
554static tree handle_tls_model_attribute (tree *, tree, tree, int,
555 bool *);
556static tree handle_no_instrument_function_attribute (tree *, tree,
557 tree, int, bool *);
558static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
559static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
560static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
561 bool *);
562static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
563static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
564static tree handle_deprecated_attribute (tree *, tree, tree, int,
565 bool *);
566static tree handle_vector_size_attribute (tree *, tree, tree, int,
567 bool *);
568static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
569static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
570static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
571static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
572 bool *);
573static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
574static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
575static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
576static tree handle_target_attribute (tree *, tree, tree, int, bool *);
577static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
578
579static void check_function_nonnull (tree, int, tree *);
580static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
581static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
582static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
583static int resort_field_decl_cmp (const void *, const void *);
584
585/* Reserved words. The third field is a mask: keywords are disabled
586 if they match the mask.
587
588 Masks for languages:
589 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
590 C --std=c99: D_CXXONLY | D_OBJC
591 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
592 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
593 C++ --std=c0x: D_CONLY | D_OBJC
594 ObjC++ is like C++ except that D_OBJC is not set
595
596 If -fno-asm is used, D_ASM is added to the mask. If
597 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
598 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
599 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
600
601const struct c_common_resword c_common_reswords[] =
602{
603 { "_Bool", RID_BOOL, D_CONLY },
604 { "_Complex", RID_COMPLEX, 0 },
605 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
606 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
607 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
608 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
609 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
610 { "_Sat", RID_SAT, D_CONLY | D_EXT },
611 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
612 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
613 { "__alignof", RID_ALIGNOF, 0 },
614 { "__alignof__", RID_ALIGNOF, 0 },
615 { "__asm", RID_ASM, 0 },
616 { "__asm__", RID_ASM, 0 },
617 { "__attribute", RID_ATTRIBUTE, 0 },
618 { "__attribute__", RID_ATTRIBUTE, 0 },
619 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
620 { "__builtin_offsetof", RID_OFFSETOF, 0 },
621 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
622 { "__builtin_va_arg", RID_VA_ARG, 0 },
623 { "__complex", RID_COMPLEX, 0 },
624 { "__complex__", RID_COMPLEX, 0 },
625 { "__const", RID_CONST, 0 },
626 { "__const__", RID_CONST, 0 },
627 { "__decltype", RID_DECLTYPE, D_CXXONLY },
628 { "__extension__", RID_EXTENSION, 0 },
629 { "__func__", RID_C99_FUNCTION_NAME, 0 },
630 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
631 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
632 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
633 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
634 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
635 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
636 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
637 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
638 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
639 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
640 { "__is_class", RID_IS_CLASS, D_CXXONLY },
641 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
642 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
643 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
644 { "__is_pod", RID_IS_POD, D_CXXONLY },
645 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
646 { "__is_union", RID_IS_UNION, D_CXXONLY },
647 { "__imag", RID_IMAGPART, 0 },
648 { "__imag__", RID_IMAGPART, 0 },
649 { "__inline", RID_INLINE, 0 },
650 { "__inline__", RID_INLINE, 0 },
651 { "__label__", RID_LABEL, 0 },
652 { "__null", RID_NULL, 0 },
653 { "__real", RID_REALPART, 0 },
654 { "__real__", RID_REALPART, 0 },
655 { "__restrict", RID_RESTRICT, 0 },
656 { "__restrict__", RID_RESTRICT, 0 },
657 { "__signed", RID_SIGNED, 0 },
658 { "__signed__", RID_SIGNED, 0 },
659 { "__thread", RID_THREAD, 0 },
660 { "__typeof", RID_TYPEOF, 0 },
661 { "__typeof__", RID_TYPEOF, 0 },
662 { "__volatile", RID_VOLATILE, 0 },
663 { "__volatile__", RID_VOLATILE, 0 },
664 { "asm", RID_ASM, D_ASM },
665 { "auto", RID_AUTO, 0 },
666 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
667 { "break", RID_BREAK, 0 },
668 { "case", RID_CASE, 0 },
669 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
670 { "char", RID_CHAR, 0 },
671 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
672 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
673 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
674 { "const", RID_CONST, 0 },
675 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
676 { "continue", RID_CONTINUE, 0 },
677 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
678 { "default", RID_DEFAULT, 0 },
679 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
680 { "do", RID_DO, 0 },
681 { "double", RID_DOUBLE, 0 },
682 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
683 { "else", RID_ELSE, 0 },
684 { "enum", RID_ENUM, 0 },
685 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
686 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
687 { "extern", RID_EXTERN, 0 },
688 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
689 { "float", RID_FLOAT, 0 },
690 { "for", RID_FOR, 0 },
691 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
692 { "goto", RID_GOTO, 0 },
693 { "if", RID_IF, 0 },
694 { "inline", RID_INLINE, D_EXT89 },
695 { "int", RID_INT, 0 },
696 { "long", RID_LONG, 0 },
697 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
698 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
699 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
700 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
701 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
702 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
703 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
704 { "register", RID_REGISTER, 0 },
705 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
706 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
707 { "return", RID_RETURN, 0 },
708 { "short", RID_SHORT, 0 },
709 { "signed", RID_SIGNED, 0 },
710 { "sizeof", RID_SIZEOF, 0 },
711 { "static", RID_STATIC, 0 },
712 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
713 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
714 { "struct", RID_STRUCT, 0 },
715 { "switch", RID_SWITCH, 0 },
716 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
717 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
718 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
719 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
720 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
721 { "typedef", RID_TYPEDEF, 0 },
722 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
723 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
724 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
725 { "union", RID_UNION, 0 },
726 { "unsigned", RID_UNSIGNED, 0 },
727 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
728 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
729 { "void", RID_VOID, 0 },
730 { "volatile", RID_VOLATILE, 0 },
731 { "wchar_t", RID_WCHAR, D_CXXONLY },
732 { "while", RID_WHILE, 0 },
733 /* These Objective-C keywords are recognized only immediately after
734 an '@'. */
735 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
736 { "defs", RID_AT_DEFS, D_OBJC },
737 { "encode", RID_AT_ENCODE, D_OBJC },
738 { "end", RID_AT_END, D_OBJC },
739 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
740 { "interface", RID_AT_INTERFACE, D_OBJC },
741 { "protocol", RID_AT_PROTOCOL, D_OBJC },
742 { "selector", RID_AT_SELECTOR, D_OBJC },
743 { "finally", RID_AT_FINALLY, D_OBJC },
744 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
745 /* These are recognized only in protocol-qualifier context
746 (see above) */
747 { "bycopy", RID_BYCOPY, D_OBJC },
748 { "byref", RID_BYREF, D_OBJC },
749 { "in", RID_IN, D_OBJC },
750 { "inout", RID_INOUT, D_OBJC },
751 { "oneway", RID_ONEWAY, D_OBJC },
752 { "out", RID_OUT, D_OBJC },
753};
754
755const unsigned int num_c_common_reswords =
756 sizeof c_common_reswords / sizeof (struct c_common_resword);
757
758/* Table of machine-independent attributes common to all C-like languages. */
759const struct attribute_spec c_common_attribute_table[] =
760{
761 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
762 { "packed", 0, 0, false, false, false,
763 handle_packed_attribute },
764 { "nocommon", 0, 0, true, false, false,
765 handle_nocommon_attribute },
766 { "common", 0, 0, true, false, false,
767 handle_common_attribute },
768 /* FIXME: logically, noreturn attributes should be listed as
769 "false, true, true" and apply to function types. But implementing this
770 would require all the places in the compiler that use TREE_THIS_VOLATILE
771 on a decl to identify non-returning functions to be located and fixed
772 to check the function type instead. */
773 { "noreturn", 0, 0, true, false, false,
774 handle_noreturn_attribute },
775 { "volatile", 0, 0, true, false, false,
776 handle_noreturn_attribute },
777 { "noinline", 0, 0, true, false, false,
778 handle_noinline_attribute },
779 { "always_inline", 0, 0, true, false, false,
780 handle_always_inline_attribute },
781 { "gnu_inline", 0, 0, true, false, false,
782 handle_gnu_inline_attribute },
783 { "artificial", 0, 0, true, false, false,
784 handle_artificial_attribute },
785 { "flatten", 0, 0, true, false, false,
786 handle_flatten_attribute },
787 { "used", 0, 0, true, false, false,
788 handle_used_attribute },
789 { "unused", 0, 0, false, false, false,
790 handle_unused_attribute },
791 { "externally_visible", 0, 0, true, false, false,
792 handle_externally_visible_attribute },
793 /* The same comments as for noreturn attributes apply to const ones. */
794 { "const", 0, 0, true, false, false,
795 handle_const_attribute },
796 { "transparent_union", 0, 0, false, false, false,
797 handle_transparent_union_attribute },
798 { "constructor", 0, 1, true, false, false,
799 handle_constructor_attribute },
800 { "destructor", 0, 1, true, false, false,
801 handle_destructor_attribute },
802 { "mode", 1, 1, false, true, false,
803 handle_mode_attribute },
804 { "section", 1, 1, true, false, false,
805 handle_section_attribute },
806 { "aligned", 0, 1, false, false, false,
807 handle_aligned_attribute },
808 { "weak", 0, 0, true, false, false,
809 handle_weak_attribute },
810 { "alias", 1, 1, true, false, false,
811 handle_alias_attribute },
812 { "weakref", 0, 1, true, false, false,
813 handle_weakref_attribute },
814 { "no_instrument_function", 0, 0, true, false, false,
815 handle_no_instrument_function_attribute },
816 { "malloc", 0, 0, true, false, false,
817 handle_malloc_attribute },
818 { "returns_twice", 0, 0, true, false, false,
819 handle_returns_twice_attribute },
820 { "no_stack_limit", 0, 0, true, false, false,
821 handle_no_limit_stack_attribute },
822 { "pure", 0, 0, true, false, false,
823 handle_pure_attribute },
824 /* For internal use (marking of builtins) only. The name contains space
825 to prevent its usage in source code. */
826 { "no vops", 0, 0, true, false, false,
827 handle_novops_attribute },
828 { "deprecated", 0, 0, false, false, false,
829 handle_deprecated_attribute },
830 { "vector_size", 1, 1, false, true, false,
831 handle_vector_size_attribute },
832 { "visibility", 1, 1, false, false, false,
833 handle_visibility_attribute },
834 { "tls_model", 1, 1, true, false, false,
835 handle_tls_model_attribute },
836 { "nonnull", 0, -1, false, true, true,
837 handle_nonnull_attribute },
838 { "nothrow", 0, 0, true, false, false,
839 handle_nothrow_attribute },
840 { "may_alias", 0, 0, false, true, false, NULL },
841 { "cleanup", 1, 1, true, false, false,
842 handle_cleanup_attribute },
843 { "warn_unused_result", 0, 0, false, true, true,
844 handle_warn_unused_result_attribute },
845 { "sentinel", 0, 1, false, true, true,
846 handle_sentinel_attribute },
847 /* For internal use (marking of builtins) only. The name contains space
848 to prevent its usage in source code. */
849 { "type generic", 0, 0, false, true, true,
850 handle_type_generic_attribute },
851 { "alloc_size", 1, 2, false, true, true,
852 handle_alloc_size_attribute },
853 { "cold", 0, 0, true, false, false,
854 handle_cold_attribute },
855 { "hot", 0, 0, true, false, false,
856 handle_hot_attribute },
857 { "warning", 1, 1, true, false, false,
858 handle_error_attribute },
859 { "error", 1, 1, true, false, false,
860 handle_error_attribute },
861 { "target", 1, -1, true, false, false,
862 handle_target_attribute },
863 { "optimize", 1, -1, true, false, false,
864 handle_optimize_attribute },
865 { NULL, 0, 0, false, false, false, NULL }
866};
867
868/* Give the specifications for the format attributes, used by C and all
869 descendants. */
870
871const struct attribute_spec c_common_format_attribute_table[] =
872{
873 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
874 { "format", 3, 3, false, true, true,
875 handle_format_attribute },
876 { "format_arg", 1, 1, false, true, true,
877 handle_format_arg_attribute },
878 { NULL, 0, 0, false, false, false, NULL }
879};
880
881/* Push current bindings for the function name VAR_DECLS. */
882
883void
884start_fname_decls (void)
885{
886 unsigned ix;
887 tree saved = NULL_TREE;
888
889 for (ix = 0; fname_vars[ix].decl; ix++)
890 {
891 tree decl = *fname_vars[ix].decl;
892
893 if (decl)
894 {
895 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
896 *fname_vars[ix].decl = NULL_TREE;
897 }
898 }
899 if (saved || saved_function_name_decls)
900 /* Normally they'll have been NULL, so only push if we've got a
901 stack, or they are non-NULL. */
902 saved_function_name_decls = tree_cons (saved, NULL_TREE,
903 saved_function_name_decls);
904}
905
906/* Finish up the current bindings, adding them into the current function's
907 statement tree. This must be done _before_ finish_stmt_tree is called.
908 If there is no current function, we must be at file scope and no statements
909 are involved. Pop the previous bindings. */
910
911void
912finish_fname_decls (void)
913{
914 unsigned ix;
915 tree stmts = NULL_TREE;
916 tree stack = saved_function_name_decls;
917
918 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
919 append_to_statement_list (TREE_VALUE (stack), &stmts);
920
921 if (stmts)
922 {
923 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
924
925 if (TREE_CODE (*bodyp) == BIND_EXPR)
926 bodyp = &BIND_EXPR_BODY (*bodyp);
927
928 append_to_statement_list_force (*bodyp, &stmts);
929 *bodyp = stmts;
930 }
931
932 for (ix = 0; fname_vars[ix].decl; ix++)
933 *fname_vars[ix].decl = NULL_TREE;
934
935 if (stack)
936 {
937 /* We had saved values, restore them. */
938 tree saved;
939
940 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
941 {
942 tree decl = TREE_PURPOSE (saved);
943 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
944
945 *fname_vars[ix].decl = decl;
946 }
947 stack = TREE_CHAIN (stack);
948 }
949 saved_function_name_decls = stack;
950}
951
952/* Return the text name of the current function, suitably prettified
953 by PRETTY_P. Return string must be freed by caller. */
954
955const char *
956fname_as_string (int pretty_p)
957{
958 const char *name = "top level";
959 char *namep;
960 int vrb = 2, len;
961 cpp_string cstr = { 0, 0 }, strname;
962
963 if (!pretty_p)
964 {
965 name = "";
966 vrb = 0;
967 }
968
969 if (current_function_decl)
970 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
971
972 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
973
974 namep = XNEWVEC (char, len);
975 snprintf (namep, len, "\"%s\"", name);
976 strname.text = (unsigned char *) namep;
977 strname.len = len - 1;
978
979 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
980 {
981 XDELETEVEC (namep);
982 return (const char *) cstr.text;
983 }
984
985 return namep;
986}
987
988/* Return the VAR_DECL for a const char array naming the current
989 function. If the VAR_DECL has not yet been created, create it
990 now. RID indicates how it should be formatted and IDENTIFIER_NODE
991 ID is its name (unfortunately C and C++ hold the RID values of
992 keywords in different places, so we can't derive RID from ID in
993 this language independent code. LOC is the location of the
994 function. */
995
996tree
997fname_decl (location_t loc, unsigned int rid, tree id)
998{
999 unsigned ix;
1000 tree decl = NULL_TREE;
1001
1002 for (ix = 0; fname_vars[ix].decl; ix++)
1003 if (fname_vars[ix].rid == rid)
1004 break;
1005
1006 decl = *fname_vars[ix].decl;
1007 if (!decl)
1008 {
1009 /* If a tree is built here, it would normally have the lineno of
1010 the current statement. Later this tree will be moved to the
1011 beginning of the function and this line number will be wrong.
1012 To avoid this problem set the lineno to 0 here; that prevents
1013 it from appearing in the RTL. */
1014 tree stmts;
1015 location_t saved_location = input_location;
1016 input_location = UNKNOWN_LOCATION;
1017
1018 stmts = push_stmt_list ();
1019 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1020 stmts = pop_stmt_list (stmts);
1021 if (!IS_EMPTY_STMT (stmts))
1022 saved_function_name_decls
1023 = tree_cons (decl, stmts, saved_function_name_decls);
1024 *fname_vars[ix].decl = decl;
1025 input_location = saved_location;
1026 }
1027 if (!ix && !current_function_decl)
1028 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1029
1030 return decl;
1031}
1032
1033/* Given a STRING_CST, give it a suitable array-of-chars data type. */
1034
1035tree
1036fix_string_type (tree value)
1037{
1038 int length = TREE_STRING_LENGTH (value);
1039 int nchars;
1040 tree e_type, i_type, a_type;
1041
1042 /* Compute the number of elements, for the array type. */
1043 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1044 {
1045 nchars = length;
1046 e_type = char_type_node;
1047 }
1048 else if (TREE_TYPE (value) == char16_array_type_node)
1049 {
1050 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1051 e_type = char16_type_node;
1052 }
1053 else if (TREE_TYPE (value) == char32_array_type_node)
1054 {
1055 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1056 e_type = char32_type_node;
1057 }
1058 else
1059 {
1060 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1061 e_type = wchar_type_node;
1062 }
1063
1064 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1065 limit in C++98 Annex B is very large (65536) and is not normative,
1066 so we do not diagnose it (warn_overlength_strings is forced off
1067 in c_common_post_options). */
1068 if (warn_overlength_strings)
1069 {
1070 const int nchars_max = flag_isoc99 ? 4095 : 509;
1071 const int relevant_std = flag_isoc99 ? 99 : 90;
1072 if (nchars - 1 > nchars_max)
1073 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1074 separate the %d from the 'C'. 'ISO' should not be
1075 translated, but it may be moved after 'C%d' in languages
1076 where modifiers follow nouns. */
1077 pedwarn (input_location, OPT_Woverlength_strings,
1078 "string length %qd is greater than the length %qd "
1079 "ISO C%d compilers are required to support",
1080 nchars - 1, nchars_max, relevant_std);
1081 }
1082
1083 /* Create the array type for the string constant. The ISO C++
1084 standard says that a string literal has type `const char[N]' or
1085 `const wchar_t[N]'. We use the same logic when invoked as a C
1086 front-end with -Wwrite-strings.
1087 ??? We should change the type of an expression depending on the
1088 state of a warning flag. We should just be warning -- see how
1089 this is handled in the C++ front-end for the deprecated implicit
1090 conversion from string literals to `char*' or `wchar_t*'.
1091
1092 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1093 array type being the unqualified version of that type.
1094 Therefore, if we are constructing an array of const char, we must
1095 construct the matching unqualified array type first. The C front
1096 end does not require this, but it does no harm, so we do it
1097 unconditionally. */
1098 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1099 a_type = build_array_type (e_type, i_type);
1100 if (c_dialect_cxx() || warn_write_strings)
1101 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1102
1103 TREE_TYPE (value) = a_type;
1104 TREE_CONSTANT (value) = 1;
1105 TREE_READONLY (value) = 1;
1106 TREE_STATIC (value) = 1;
1107 return value;
1108}
1109\f
1110/* Print a warning if a constant expression had overflow in folding.
1111 Invoke this function on every expression that the language
1112 requires to be a constant expression.
1113 Note the ANSI C standard says it is erroneous for a
1114 constant expression to overflow. */
1115
1116void
1117constant_expression_warning (tree value)
1118{
1119 if (warn_overflow && pedantic
1120 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1121 || TREE_CODE (value) == FIXED_CST
1122 || TREE_CODE (value) == VECTOR_CST
1123 || TREE_CODE (value) == COMPLEX_CST)
1124 && TREE_OVERFLOW (value))
1125 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1126}
1127
1128/* The same as above but print an unconditional error. */
1129void
1130constant_expression_error (tree value)
1131{
1132 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1133 || TREE_CODE (value) == FIXED_CST
1134 || TREE_CODE (value) == VECTOR_CST
1135 || TREE_CODE (value) == COMPLEX_CST)
1136 && TREE_OVERFLOW (value))
1137 error ("overflow in constant expression");
1138}
1139
1140/* Print a warning if an expression had overflow in folding and its
1141 operands hadn't.
1142
1143 Invoke this function on every expression that
1144 (1) appears in the source code, and
1145 (2) is a constant expression that overflowed, and
1146 (3) is not already checked by convert_and_check;
1147 however, do not invoke this function on operands of explicit casts
1148 or when the expression is the result of an operator and any operand
1149 already overflowed. */
1150
1151void
1152overflow_warning (tree value)
1153{
1154 if (skip_evaluation) return;
1155
1156 switch (TREE_CODE (value))
1157 {
1158 case INTEGER_CST:
1159 warning (OPT_Woverflow, "integer overflow in expression");
1160 break;
1161
1162 case REAL_CST:
1163 warning (OPT_Woverflow, "floating point overflow in expression");
1164 break;
1165
1166 case FIXED_CST:
1167 warning (OPT_Woverflow, "fixed-point overflow in expression");
1168 break;
1169
1170 case VECTOR_CST:
1171 warning (OPT_Woverflow, "vector overflow in expression");
1172 break;
1173
1174 case COMPLEX_CST:
1175 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1176 warning (OPT_Woverflow, "complex integer overflow in expression");
1177 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1178 warning (OPT_Woverflow, "complex floating point overflow in expression");
1179 break;
1180
1181 default:
1182 break;
1183 }
1184}
1185
1186
1187/* Warn about use of a logical || / && operator being used in a
1188 context where it is likely that the bitwise equivalent was intended
1189 by the programmer. CODE is the TREE_CODE of the operator, ARG1
1190 and ARG2 the arguments. */
1191
1192void
1193warn_logical_operator (enum tree_code code, tree arg1, tree
1194 arg2)
1195{
1196 switch (code)
1197 {
1198 case TRUTH_ANDIF_EXPR:
1199 case TRUTH_ORIF_EXPR:
1200 case TRUTH_OR_EXPR:
1201 case TRUTH_AND_EXPR:
1202 if (!TREE_NO_WARNING (arg1)
1203 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1204 && !CONSTANT_CLASS_P (arg1)
1205 && TREE_CODE (arg2) == INTEGER_CST
1206 && !integer_zerop (arg2))
1207 {
1208 warning (OPT_Wlogical_op,
1209 "logical %<%s%> with non-zero constant "
1210 "will always evaluate as true",
1211 ((code == TRUTH_ANDIF_EXPR)
1212 || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1213 TREE_NO_WARNING (arg1) = true;
1214 }
1215 break;
1216 default:
1217 break;
1218 }
1219}
1220
1221
1222/* Print a warning about casts that might indicate violation
1223 of strict aliasing rules if -Wstrict-aliasing is used and
1224 strict aliasing mode is in effect. OTYPE is the original
1225 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1226
1227bool
1228strict_aliasing_warning (tree otype, tree type, tree expr)
1229{
1230 if (!(flag_strict_aliasing
1231 && POINTER_TYPE_P (type)
1232 && POINTER_TYPE_P (otype)
1233 && !VOID_TYPE_P (TREE_TYPE (type)))
1234 /* If the type we are casting to is a ref-all pointer
1235 dereferencing it is always valid. */
1236 || TYPE_REF_CAN_ALIAS_ALL (type))
1237 return false;
1238
1239 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1240 && (DECL_P (TREE_OPERAND (expr, 0))
1241 || handled_component_p (TREE_OPERAND (expr, 0))))
1242 {
1243 /* Casting the address of an object to non void pointer. Warn
1244 if the cast breaks type based aliasing. */
1245 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1246 {
1247 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1248 "might break strict-aliasing rules");
1249 return true;
1250 }
1251 else
1252 {
1253 /* warn_strict_aliasing >= 3. This includes the default (3).
1254 Only warn if the cast is dereferenced immediately. */
1255 alias_set_type set1 =
1256 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1257 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1258
1259 if (set1 != set2 && set2 != 0
1260 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1261 {
1262 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1263 "pointer will break strict-aliasing rules");
1264 return true;
1265 }
1266 else if (warn_strict_aliasing == 2
1267 && !alias_sets_must_conflict_p (set1, set2))
1268 {
1269 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1270 "pointer might break strict-aliasing rules");
1271 return true;
1272 }
1273 }
1274 }
1275 else
1276 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1277 {
1278 /* At this level, warn for any conversions, even if an address is
1279 not taken in the same statement. This will likely produce many
1280 false positives, but could be useful to pinpoint problems that
1281 are not revealed at higher levels. */
1282 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1283 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1284 if (!COMPLETE_TYPE_P (type)
1285 || !alias_sets_must_conflict_p (set1, set2))
1286 {
1287 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1288 "pointer might break strict-aliasing rules");
1289 return true;
1290 }
1291 }
1292
1293 return false;
1294}
1295
1296/* Warn for unlikely, improbable, or stupid DECL declarations
1297 of `main'. */
1298
1299void
1300check_main_parameter_types (tree decl)
1301{
1302 tree args;
1303 int argct = 0;
1304
1305 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1306 args = TREE_CHAIN (args))
1307 {
1308 tree type = args ? TREE_VALUE (args) : 0;
1309
1310 if (type == void_type_node || type == error_mark_node )
1311 break;
1312
1313 ++argct;
1314 switch (argct)
1315 {
1316 case 1:
1317 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1318 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1319 decl);
1320 break;
1321
1322 case 2:
1323 if (TREE_CODE (type) != POINTER_TYPE
1324 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1325 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1326 != char_type_node))
1327 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1328 decl);
1329 break;
1330
1331 case 3:
1332 if (TREE_CODE (type) != POINTER_TYPE
1333 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1334 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1335 != char_type_node))
1336 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1337 "%<char **%>", decl);
1338 break;
1339 }
1340 }
1341
1342 /* It is intentional that this message does not mention the third
1343 argument because it's only mentioned in an appendix of the
1344 standard. */
1345 if (argct > 0 && (argct < 2 || argct > 3))
1346 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1347}
1348
1349/* True if pointers to distinct types T1 and T2 can be converted to
1350 each other without an explicit cast. Only returns true for opaque
1351 vector types. */
1352bool
1353vector_targets_convertible_p (const_tree t1, const_tree t2)
1354{
1355 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1356 && (targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1357 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1358 return true;
1359
1360 return false;
1361}
1362
1363/* True if vector types T1 and T2 can be converted to each other
1364 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1365 can only be converted with -flax-vector-conversions yet that is not
1366 in effect, emit a note telling the user about that option if such
1367 a note has not previously been emitted. */
1368bool
1369vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1370{
1371 static bool emitted_lax_note = false;
1372 bool convertible_lax;
1373
1374 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1375 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1376 return true;
1377
1378 convertible_lax =
1379 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1380 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1381 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1382 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1383 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1384
1385 if (!convertible_lax || flag_lax_vector_conversions)
1386 return convertible_lax;
1387
1388 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1389 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1390 return true;
1391
1392 if (emit_lax_note && !emitted_lax_note)
1393 {
1394 emitted_lax_note = true;
1395 inform (input_location, "use -flax-vector-conversions to permit "
1396 "conversions between vectors with differing "
1397 "element types or numbers of subparts");
1398 }
1399
1400 return false;
1401}
1402
1403/* This is a helper function of build_binary_op.
1404
1405 For certain operations if both args were extended from the same
1406 smaller type, do the arithmetic in that type and then extend.
1407
1408 BITWISE indicates a bitwise operation.
1409 For them, this optimization is safe only if
1410 both args are zero-extended or both are sign-extended.
1411 Otherwise, we might change the result.
1412 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1413 but calculated in (unsigned short) it would be (unsigned short)-1.
1414*/
1415tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1416{
1417 int unsigned0, unsigned1;
1418 tree arg0, arg1;
1419 int uns;
1420 tree type;
1421
1422 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1423 excessive narrowing when we call get_narrower below. For
1424 example, suppose that OP0 is of unsigned int extended
1425 from signed char and that RESULT_TYPE is long long int.
1426 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1427 like
1428
1429 (long long int) (unsigned int) signed_char
1430
1431 which get_narrower would narrow down to
1432
1433 (unsigned int) signed char
1434
1435 If we do not cast OP0 first, get_narrower would return
1436 signed_char, which is inconsistent with the case of the
1437 explicit cast. */
1438 op0 = convert (result_type, op0);
1439 op1 = convert (result_type, op1);
1440
1441 arg0 = get_narrower (op0, &unsigned0);
1442 arg1 = get_narrower (op1, &unsigned1);
1443
1444 /* UNS is 1 if the operation to be done is an unsigned one. */
1445 uns = TYPE_UNSIGNED (result_type);
1446
1447 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1448 but it *requires* conversion to FINAL_TYPE. */
1449
1450 if ((TYPE_PRECISION (TREE_TYPE (op0))
1451 == TYPE_PRECISION (TREE_TYPE (arg0)))
1452 && TREE_TYPE (op0) != result_type)
1453 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1454 if ((TYPE_PRECISION (TREE_TYPE (op1))
1455 == TYPE_PRECISION (TREE_TYPE (arg1)))
1456 && TREE_TYPE (op1) != result_type)
1457 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1458
1459 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1460
1461 /* For bitwise operations, signedness of nominal type
1462 does not matter. Consider only how operands were extended. */
1463 if (bitwise)
1464 uns = unsigned0;
1465
1466 /* Note that in all three cases below we refrain from optimizing
1467 an unsigned operation on sign-extended args.
1468 That would not be valid. */
1469
1470 /* Both args variable: if both extended in same way
1471 from same width, do it in that width.
1472 Do it unsigned if args were zero-extended. */
1473 if ((TYPE_PRECISION (TREE_TYPE (arg0))
1474 < TYPE_PRECISION (result_type))
1475 && (TYPE_PRECISION (TREE_TYPE (arg1))
1476 == TYPE_PRECISION (TREE_TYPE (arg0)))
1477 && unsigned0 == unsigned1
1478 && (unsigned0 || !uns))
1479 return c_common_signed_or_unsigned_type
1480 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1481
1482 else if (TREE_CODE (arg0) == INTEGER_CST
1483 && (unsigned1 || !uns)
1484 && (TYPE_PRECISION (TREE_TYPE (arg1))
1485 < TYPE_PRECISION (result_type))
1486 && (type
1487 = c_common_signed_or_unsigned_type (unsigned1,
1488 TREE_TYPE (arg1)))
1489 && !POINTER_TYPE_P (type)
1490 && int_fits_type_p (arg0, type))
1491 return type;
1492
1493 else if (TREE_CODE (arg1) == INTEGER_CST
1494 && (unsigned0 || !uns)
1495 && (TYPE_PRECISION (TREE_TYPE (arg0))
1496 < TYPE_PRECISION (result_type))
1497 && (type
1498 = c_common_signed_or_unsigned_type (unsigned0,
1499 TREE_TYPE (arg0)))
1500 && !POINTER_TYPE_P (type)
1501 && int_fits_type_p (arg1, type))
1502 return type;
1503
1504 return result_type;
1505}
1506
1507/* Warns if the conversion of EXPR to TYPE may alter a value.
1508 This is a helper function for warnings_for_convert_and_check. */
1509
1510static void
1511conversion_warning (tree type, tree expr)
1512{
1513 bool give_warning = false;
1514
1515 int i;
1516 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1517 tree expr_type = TREE_TYPE (expr);
1518
1519 if (!warn_conversion && !warn_sign_conversion)
1520 return;
1521
1522 /* If any operand is artificial, then this expression was generated
1523 by the compiler and we do not warn. */
1524 for (i = 0; i < expr_num_operands; i++)
1525 {
1526 tree op = TREE_OPERAND (expr, i);
1527 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1528 return;
1529 }
1530
1531 switch (TREE_CODE (expr))
1532 {
1533 case EQ_EXPR:
1534 case NE_EXPR:
1535 case LE_EXPR:
1536 case GE_EXPR:
1537 case LT_EXPR:
1538 case GT_EXPR:
1539 case TRUTH_ANDIF_EXPR:
1540 case TRUTH_ORIF_EXPR:
1541 case TRUTH_AND_EXPR:
1542 case TRUTH_OR_EXPR:
1543 case TRUTH_XOR_EXPR:
1544 case TRUTH_NOT_EXPR:
1545 /* Conversion from boolean to a signed:1 bit-field (which only
1546 can hold the values 0 and -1) doesn't lose information - but
1547 it does change the value. */
1548 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
1549 warning (OPT_Wconversion,
1550 "conversion to %qT from boolean expression", type);
1551 return;
1552
1553 case REAL_CST:
1554 case INTEGER_CST:
1555
1556 /* Warn for real constant that is not an exact integer converted
1557 to integer type. */
1558 if (TREE_CODE (expr_type) == REAL_TYPE
1559 && TREE_CODE (type) == INTEGER_TYPE)
1560 {
1561 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1562 give_warning = true;
1563 }
1564 /* Warn for an integer constant that does not fit into integer type. */
1565 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1566 && TREE_CODE (type) == INTEGER_TYPE
1567 && !int_fits_type_p (expr, type))
1568 {
1569 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
1570 && tree_int_cst_sgn (expr) < 0)
1571 warning (OPT_Wsign_conversion,
1572 "negative integer implicitly converted to unsigned type");
1573 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1574 warning (OPT_Wsign_conversion, "conversion of unsigned constant "
1575 "value to negative integer");
1576 else
1577 give_warning = true;
1578 }
1579 else if (TREE_CODE (type) == REAL_TYPE)
1580 {
1581 /* Warn for an integer constant that does not fit into real type. */
1582 if (TREE_CODE (expr_type) == INTEGER_TYPE)
1583 {
1584 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1585 if (!exact_real_truncate (TYPE_MODE (type), &a))
1586 give_warning = true;
1587 }
1588 /* Warn for a real constant that does not fit into a smaller
1589 real type. */
1590 else if (TREE_CODE (expr_type) == REAL_TYPE
1591 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1592 {
1593 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1594 if (!exact_real_truncate (TYPE_MODE (type), &a))
1595 give_warning = true;
1596 }
1597 }
1598
1599 if (give_warning)
1600 warning (OPT_Wconversion,
1601 "conversion to %qT alters %qT constant value",
1602 type, expr_type);
1603
1604 return;
1605
1606 case COND_EXPR:
1607 {
1608 /* In case of COND_EXPR, if both operands are constants or
1609 COND_EXPR, then we do not care about the type of COND_EXPR,
1610 only about the conversion of each operand. */
1611 tree op1 = TREE_OPERAND (expr, 1);
1612 tree op2 = TREE_OPERAND (expr, 2);
1613
1614 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
1615 || TREE_CODE (op1) == COND_EXPR)
1616 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1617 || TREE_CODE (op2) == COND_EXPR))
1618 {
1619 conversion_warning (type, op1);
1620 conversion_warning (type, op2);
1621 return;
1622 }
1623 /* Fall through. */
1624 }
1625
1626 default: /* 'expr' is not a constant. */
1627
1628 /* Warn for real types converted to integer types. */
1629 if (TREE_CODE (expr_type) == REAL_TYPE
1630 && TREE_CODE (type) == INTEGER_TYPE)
1631 give_warning = true;
1632
1633 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1634 && TREE_CODE (type) == INTEGER_TYPE)
1635 {
1636 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1637 expr = get_unwidened (expr, 0);
1638 expr_type = TREE_TYPE (expr);
1639
1640 /* Don't warn for short y; short x = ((int)y & 0xff); */
1641 if (TREE_CODE (expr) == BIT_AND_EXPR
1642 || TREE_CODE (expr) == BIT_IOR_EXPR
1643 || TREE_CODE (expr) == BIT_XOR_EXPR)
1644 {
1645 /* If both args were extended from a shortest type,
1646 use that type if that is safe. */
1647 expr_type = shorten_binary_op (expr_type,
1648 TREE_OPERAND (expr, 0),
1649 TREE_OPERAND (expr, 1),
1650 /* bitwise */1);
1651
1652 if (TREE_CODE (expr) == BIT_AND_EXPR)
1653 {
1654 tree op0 = TREE_OPERAND (expr, 0);
1655 tree op1 = TREE_OPERAND (expr, 1);
1656 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1657 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1658
1659 /* If one of the operands is a non-negative constant
1660 that fits in the target type, then the type of the
1661 other operand does not matter. */
1662 if ((TREE_CODE (op0) == INTEGER_CST
1663 && int_fits_type_p (op0, c_common_signed_type (type))
1664 && int_fits_type_p (op0, c_common_unsigned_type (type)))
1665 || (TREE_CODE (op1) == INTEGER_CST
1666 && int_fits_type_p (op1, c_common_signed_type (type))
1667 && int_fits_type_p (op1,
1668 c_common_unsigned_type (type))))
1669 return;
1670 /* If constant is unsigned and fits in the target
1671 type, then the result will also fit. */
1672 else if ((TREE_CODE (op0) == INTEGER_CST
1673 && unsigned0
1674 && int_fits_type_p (op0, type))
1675 || (TREE_CODE (op1) == INTEGER_CST
1676 && unsigned1
1677 && int_fits_type_p (op1, type)))
1678 return;
1679 }
1680 }
1681 /* Warn for integer types converted to smaller integer types. */
1682 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1683 give_warning = true;
1684
1685 /* When they are the same width but different signedness,
1686 then the value may change. */
1687 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
1688 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
1689 /* Even when converted to a bigger type, if the type is
1690 unsigned but expr is signed, then negative values
1691 will be changed. */
1692 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
1693 warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
1694 "may change the sign of the result",
1695 type, expr_type);
1696 }
1697
1698 /* Warn for integer types converted to real types if and only if
1699 all the range of values of the integer type cannot be
1700 represented by the real type. */
1701 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1702 && TREE_CODE (type) == REAL_TYPE)
1703 {
1704 tree type_low_bound = TYPE_MIN_VALUE (expr_type);
1705 tree type_high_bound = TYPE_MAX_VALUE (expr_type);
1706 REAL_VALUE_TYPE real_low_bound
1707 = real_value_from_int_cst (0, type_low_bound);
1708 REAL_VALUE_TYPE real_high_bound
1709 = real_value_from_int_cst (0, type_high_bound);
1710
1711 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1712 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1713 give_warning = true;
1714 }
1715
1716 /* Warn for real types converted to smaller real types. */
1717 else if (TREE_CODE (expr_type) == REAL_TYPE
1718 && TREE_CODE (type) == REAL_TYPE
1719 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1720 give_warning = true;
1721
1722
1723 if (give_warning)
1724 warning (OPT_Wconversion,
1725 "conversion to %qT from %qT may alter its value",
1726 type, expr_type);
1727 }
1728}
1729
1730/* Produce warnings after a conversion. RESULT is the result of
1731 converting EXPR to TYPE. This is a helper function for
1732 convert_and_check and cp_convert_and_check. */
1733
1734void
1735warnings_for_convert_and_check (tree type, tree expr, tree result)
1736{
1737 if (TREE_CODE (expr) == INTEGER_CST
1738 && (TREE_CODE (type) == INTEGER_TYPE
1739 || TREE_CODE (type) == ENUMERAL_TYPE)
1740 && !int_fits_type_p (expr, type))
1741 {
1742 /* Do not diagnose overflow in a constant expression merely
1743 because a conversion overflowed. */
1744 if (TREE_OVERFLOW (result))
1745 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1746
1747 if (TYPE_UNSIGNED (type))
1748 {
1749 /* This detects cases like converting -129 or 256 to
1750 unsigned char. */
1751 if (!int_fits_type_p (expr, c_common_signed_type (type)))
1752 warning (OPT_Woverflow,
1753 "large integer implicitly truncated to unsigned type");
1754 else
1755 conversion_warning (type, expr);
1756 }
1757 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1758 warning (OPT_Woverflow,
1759 "overflow in implicit constant conversion");
1760 /* No warning for converting 0x80000000 to int. */
1761 else if (pedantic
1762 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1763 || TYPE_PRECISION (TREE_TYPE (expr))
1764 != TYPE_PRECISION (type)))
1765 warning (OPT_Woverflow,
1766 "overflow in implicit constant conversion");
1767
1768 else
1769 conversion_warning (type, expr);
1770 }
1771 else if ((TREE_CODE (result) == INTEGER_CST
1772 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
1773 warning (OPT_Woverflow,
1774 "overflow in implicit constant conversion");
1775 else
1776 conversion_warning (type, expr);
1777}
1778
1779
1780/* Convert EXPR to TYPE, warning about conversion problems with constants.
1781 Invoke this function on every expression that is converted implicitly,
1782 i.e. because of language rules and not because of an explicit cast. */
1783
1784tree
1785convert_and_check (tree type, tree expr)
1786{
1787 tree result;
1788
1789 if (TREE_TYPE (expr) == type)
1790 return expr;
1791
1792 result = convert (type, expr);
1793
1794 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1795 warnings_for_convert_and_check (type, expr, result);
1796
1797 return result;
1798}
1799\f
1800/* A node in a list that describes references to variables (EXPR), which are
1801 either read accesses if WRITER is zero, or write accesses, in which case
1802 WRITER is the parent of EXPR. */
1803struct tlist
1804{
1805 struct tlist *next;
1806 tree expr, writer;
1807};
1808
1809/* Used to implement a cache the results of a call to verify_tree. We only
1810 use this for SAVE_EXPRs. */
1811struct tlist_cache
1812{
1813 struct tlist_cache *next;
1814 struct tlist *cache_before_sp;
1815 struct tlist *cache_after_sp;
1816 tree expr;
1817};
1818
1819/* Obstack to use when allocating tlist structures, and corresponding
1820 firstobj. */
1821static struct obstack tlist_obstack;
1822static char *tlist_firstobj = 0;
1823
1824/* Keep track of the identifiers we've warned about, so we can avoid duplicate
1825 warnings. */
1826static struct tlist *warned_ids;
1827/* SAVE_EXPRs need special treatment. We process them only once and then
1828 cache the results. */
1829static struct tlist_cache *save_expr_cache;
1830
1831static void add_tlist (struct tlist **, struct tlist *, tree, int);
1832static void merge_tlist (struct tlist **, struct tlist *, int);
1833static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1834static int warning_candidate_p (tree);
1835static void warn_for_collisions (struct tlist *);
1836static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1837static struct tlist *new_tlist (struct tlist *, tree, tree);
1838
1839/* Create a new struct tlist and fill in its fields. */
1840static struct tlist *
1841new_tlist (struct tlist *next, tree t, tree writer)
1842{
1843 struct tlist *l;
1844 l = XOBNEW (&tlist_obstack, struct tlist);
1845 l->next = next;
1846 l->expr = t;
1847 l->writer = writer;
1848 return l;
1849}
1850
1851/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1852 is nonnull, we ignore any node we find which has a writer equal to it. */
1853
1854static void
1855add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1856{
1857 while (add)
1858 {
1859 struct tlist *next = add->next;
1860 if (!copy)
1861 add->next = *to;
1862 if (!exclude_writer || add->writer != exclude_writer)
1863 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1864 add = next;
1865 }
1866}
1867
1868/* Merge the nodes of ADD into TO. This merging process is done so that for
1869 each variable that already exists in TO, no new node is added; however if
1870 there is a write access recorded in ADD, and an occurrence on TO is only
1871 a read access, then the occurrence in TO will be modified to record the
1872 write. */
1873
1874static void
1875merge_tlist (struct tlist **to, struct tlist *add, int copy)
1876{
1877 struct tlist **end = to;
1878
1879 while (*end)
1880 end = &(*end)->next;
1881
1882 while (add)
1883 {
1884 int found = 0;
1885 struct tlist *tmp2;
1886 struct tlist *next = add->next;
1887
1888 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1889 if (tmp2->expr == add->expr)
1890 {
1891 found = 1;
1892 if (!tmp2->writer)
1893 tmp2->writer = add->writer;
1894 }
1895 if (!found)
1896 {
1897 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1898 end = &(*end)->next;
1899 *end = 0;
1900 }
1901 add = next;
1902 }
1903}
1904
1905/* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1906 references in list LIST conflict with it, excluding reads if ONLY writers
1907 is nonzero. */
1908
1909static void
1910warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1911 int only_writes)
1912{
1913 struct tlist *tmp;
1914
1915 /* Avoid duplicate warnings. */
1916 for (tmp = warned_ids; tmp; tmp = tmp->next)
1917 if (tmp->expr == written)
1918 return;
1919
1920 while (list)
1921 {
1922 if (list->expr == written
1923 && list->writer != writer
1924 && (!only_writes || list->writer)
1925 && DECL_NAME (list->expr))
1926 {
1927 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1928 warning_at (EXPR_HAS_LOCATION (writer)
1929 ? EXPR_LOCATION (writer) : input_location,
1930 OPT_Wsequence_point, "operation on %qE may be undefined",
1931 list->expr);
1932 }
1933 list = list->next;
1934 }
1935}
1936
1937/* Given a list LIST of references to variables, find whether any of these
1938 can cause conflicts due to missing sequence points. */
1939
1940static void
1941warn_for_collisions (struct tlist *list)
1942{
1943 struct tlist *tmp;
1944
1945 for (tmp = list; tmp; tmp = tmp->next)
1946 {
1947 if (tmp->writer)
1948 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1949 }
1950}
1951
1952/* Return nonzero if X is a tree that can be verified by the sequence point
1953 warnings. */
1954static int
1955warning_candidate_p (tree x)
1956{
1957 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1958}
1959
1960/* Walk the tree X, and record accesses to variables. If X is written by the
1961 parent tree, WRITER is the parent.
1962 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1963 expression or its only operand forces a sequence point, then everything up
1964 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1965 in PNO_SP.
1966 Once we return, we will have emitted warnings if any subexpression before
1967 such a sequence point could be undefined. On a higher level, however, the
1968 sequence point may not be relevant, and we'll merge the two lists.
1969
1970 Example: (b++, a) + b;
1971 The call that processes the COMPOUND_EXPR will store the increment of B
1972 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1973 processes the PLUS_EXPR will need to merge the two lists so that
1974 eventually, all accesses end up on the same list (and we'll warn about the
1975 unordered subexpressions b++ and b.
1976
1977 A note on merging. If we modify the former example so that our expression
1978 becomes
1979 (b++, b) + a
1980 care must be taken not simply to add all three expressions into the final
1981 PNO_SP list. The function merge_tlist takes care of that by merging the
1982 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1983 way, so that no more than one access to B is recorded. */
1984
1985static void
1986verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1987 tree writer)
1988{
1989 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1990 enum tree_code code;
1991 enum tree_code_class cl;
1992
1993 /* X may be NULL if it is the operand of an empty statement expression
1994 ({ }). */
1995 if (x == NULL)
1996 return;
1997
1998 restart:
1999 code = TREE_CODE (x);
2000 cl = TREE_CODE_CLASS (code);
2001
2002 if (warning_candidate_p (x))
2003 {
2004 *pno_sp = new_tlist (*pno_sp, x, writer);
2005 return;
2006 }
2007
2008 switch (code)
2009 {
2010 case CONSTRUCTOR:
2011 return;
2012
2013 case COMPOUND_EXPR:
2014 case TRUTH_ANDIF_EXPR:
2015 case TRUTH_ORIF_EXPR:
2016 tmp_before = tmp_nosp = tmp_list3 = 0;
2017 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2018 warn_for_collisions (tmp_nosp);
2019 merge_tlist (pbefore_sp, tmp_before, 0);
2020 merge_tlist (pbefore_sp, tmp_nosp, 0);
2021 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2022 merge_tlist (pbefore_sp, tmp_list3, 0);
2023 return;
2024
2025 case COND_EXPR:
2026 tmp_before = tmp_list2 = 0;
2027 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2028 warn_for_collisions (tmp_list2);
2029 merge_tlist (pbefore_sp, tmp_before, 0);
2030 merge_tlist (pbefore_sp, tmp_list2, 1);
2031
2032 tmp_list3 = tmp_nosp = 0;
2033 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2034 warn_for_collisions (tmp_nosp);
2035 merge_tlist (pbefore_sp, tmp_list3, 0);
2036
2037 tmp_list3 = tmp_list2 = 0;
2038 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2039 warn_for_collisions (tmp_list2);
2040 merge_tlist (pbefore_sp, tmp_list3, 0);
2041 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2042 two first, to avoid warning for (a ? b++ : b++). */
2043 merge_tlist (&tmp_nosp, tmp_list2, 0);
2044 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2045 return;
2046
2047 case PREDECREMENT_EXPR:
2048 case PREINCREMENT_EXPR:
2049 case POSTDECREMENT_EXPR:
2050 case POSTINCREMENT_EXPR:
2051 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2052 return;
2053
2054 case MODIFY_EXPR:
2055 tmp_before = tmp_nosp = tmp_list3 = 0;
2056 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2057 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2058 /* Expressions inside the LHS are not ordered wrt. the sequence points
2059 in the RHS. Example:
2060 *a = (a++, 2)
2061 Despite the fact that the modification of "a" is in the before_sp
2062 list (tmp_before), it conflicts with the use of "a" in the LHS.
2063 We can handle this by adding the contents of tmp_list3
2064 to those of tmp_before, and redoing the collision warnings for that
2065 list. */
2066 add_tlist (&tmp_before, tmp_list3, x, 1);
2067 warn_for_collisions (tmp_before);
2068 /* Exclude the LHS itself here; we first have to merge it into the
2069 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2070 didn't exclude the LHS, we'd get it twice, once as a read and once
2071 as a write. */
2072 add_tlist (pno_sp, tmp_list3, x, 0);
2073 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2074
2075 merge_tlist (pbefore_sp, tmp_before, 0);
2076 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2077 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2078 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2079 return;
2080
2081 case CALL_EXPR:
2082 /* We need to warn about conflicts among arguments and conflicts between
2083 args and the function address. Side effects of the function address,
2084 however, are not ordered by the sequence point of the call. */
2085 {
2086 call_expr_arg_iterator iter;
2087 tree arg;
2088 tmp_before = tmp_nosp = 0;
2089 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2090 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2091 {
2092 tmp_list2 = tmp_list3 = 0;
2093 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2094 merge_tlist (&tmp_list3, tmp_list2, 0);
2095 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2096 }
2097 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2098 warn_for_collisions (tmp_before);
2099 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2100 return;
2101 }
2102
2103 case TREE_LIST:
2104 /* Scan all the list, e.g. indices of multi dimensional array. */
2105 while (x)
2106 {
2107 tmp_before = tmp_nosp = 0;
2108 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2109 merge_tlist (&tmp_nosp, tmp_before, 0);
2110 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2111 x = TREE_CHAIN (x);
2112 }
2113 return;
2114
2115 case SAVE_EXPR:
2116 {
2117 struct tlist_cache *t;
2118 for (t = save_expr_cache; t; t = t->next)
2119 if (t->expr == x)
2120 break;
2121
2122 if (!t)
2123 {
2124 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2125 t->next = save_expr_cache;
2126 t->expr = x;
2127 save_expr_cache = t;
2128
2129 tmp_before = tmp_nosp = 0;
2130 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2131 warn_for_collisions (tmp_nosp);
2132
2133 tmp_list3 = 0;
2134 while (tmp_nosp)
2135 {
2136 struct tlist *t = tmp_nosp;
2137 tmp_nosp = t->next;
2138 merge_tlist (&tmp_list3, t, 0);
2139 }
2140 t->cache_before_sp = tmp_before;
2141 t->cache_after_sp = tmp_list3;
2142 }
2143 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2144 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2145 return;
2146 }
2147
2148 case ADDR_EXPR:
2149 x = TREE_OPERAND (x, 0);
2150 if (DECL_P (x))
2151 return;
2152 writer = 0;
2153 goto restart;
2154
2155 default:
2156 /* For other expressions, simply recurse on their operands.
2157 Manual tail recursion for unary expressions.
2158 Other non-expressions need not be processed. */
2159 if (cl == tcc_unary)
2160 {
2161 x = TREE_OPERAND (x, 0);
2162 writer = 0;
2163 goto restart;
2164 }
2165 else if (IS_EXPR_CODE_CLASS (cl))
2166 {
2167 int lp;
2168 int max = TREE_OPERAND_LENGTH (x);
2169 for (lp = 0; lp < max; lp++)
2170 {
2171 tmp_before = tmp_nosp = 0;
2172 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2173 merge_tlist (&tmp_nosp, tmp_before, 0);
2174 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2175 }
2176 }
2177 return;
2178 }
2179}
2180
2181/* Try to warn for undefined behavior in EXPR due to missing sequence
2182 points. */
2183
2184void
2185verify_sequence_points (tree expr)
2186{
2187 struct tlist *before_sp = 0, *after_sp = 0;
2188
2189 warned_ids = 0;
2190 save_expr_cache = 0;
2191 if (tlist_firstobj == 0)
2192 {
2193 gcc_obstack_init (&tlist_obstack);
2194 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2195 }
2196
2197 verify_tree (expr, &before_sp, &after_sp, 0);
2198 warn_for_collisions (after_sp);
2199 obstack_free (&tlist_obstack, tlist_firstobj);
2200}
2201\f
2202/* Validate the expression after `case' and apply default promotions. */
2203
2204static tree
2205check_case_value (tree value)
2206{
2207 if (value == NULL_TREE)
2208 return value;
2209
2210 /* ??? Can we ever get nops here for a valid case value? We
2211 shouldn't for C. */
2212 STRIP_TYPE_NOPS (value);
2213 /* In C++, the following is allowed:
2214
2215 const int i = 3;
2216 switch (...) { case i: ... }
2217
2218 So, we try to reduce the VALUE to a constant that way. */
2219 if (c_dialect_cxx ())
2220 {
2221 value = decl_constant_value (value);
2222 STRIP_TYPE_NOPS (value);
2223 value = fold (value);
2224 }
2225
2226 if (TREE_CODE (value) == INTEGER_CST)
2227 /* Promote char or short to int. */
2228 value = perform_integral_promotions (value);
2229 else if (value != error_mark_node)
2230 {
2231 error ("case label does not reduce to an integer constant");
2232 value = error_mark_node;
2233 }
2234
2235 constant_expression_warning (value);
2236
2237 return value;
2238}
2239\f
2240/* See if the case values LOW and HIGH are in the range of the original
2241 type (i.e. before the default conversion to int) of the switch testing
2242 expression.
2243 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2244 the type before promoting it. CASE_LOW_P is a pointer to the lower
2245 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2246 if the case is not a case range.
2247 The caller has to make sure that we are not called with NULL for
2248 CASE_LOW_P (i.e. the default case).
2249 Returns true if the case label is in range of ORIG_TYPE (saturated or
2250 untouched) or false if the label is out of range. */
2251
2252static bool
2253check_case_bounds (tree type, tree orig_type,
2254 tree *case_low_p, tree *case_high_p)
2255{
2256 tree min_value, max_value;
2257 tree case_low = *case_low_p;
2258 tree case_high = case_high_p ? *case_high_p : case_low;
2259
2260 /* If there was a problem with the original type, do nothing. */
2261 if (orig_type == error_mark_node)
2262 return true;
2263
2264 min_value = TYPE_MIN_VALUE (orig_type);
2265 max_value = TYPE_MAX_VALUE (orig_type);
2266
2267 /* Case label is less than minimum for type. */
2268 if (tree_int_cst_compare (case_low, min_value) < 0
2269 && tree_int_cst_compare (case_high, min_value) < 0)
2270 {
2271 warning (0, "case label value is less than minimum value for type");
2272 return false;
2273 }
2274
2275 /* Case value is greater than maximum for type. */
2276 if (tree_int_cst_compare (case_low, max_value) > 0
2277 && tree_int_cst_compare (case_high, max_value) > 0)
2278 {
2279 warning (0, "case label value exceeds maximum value for type");
2280 return false;
2281 }
2282
2283 /* Saturate lower case label value to minimum. */
2284 if (tree_int_cst_compare (case_high, min_value) >= 0
2285 && tree_int_cst_compare (case_low, min_value) < 0)
2286 {
2287 warning (0, "lower value in case label range"
2288 " less than minimum value for type");
2289 case_low = min_value;
2290 }
2291
2292 /* Saturate upper case label value to maximum. */
2293 if (tree_int_cst_compare (case_low, max_value) <= 0
2294 && tree_int_cst_compare (case_high, max_value) > 0)
2295 {
2296 warning (0, "upper value in case label range"
2297 " exceeds maximum value for type");
2298 case_high = max_value;
2299 }
2300
2301 if (*case_low_p != case_low)
2302 *case_low_p = convert (type, case_low);
2303 if (case_high_p && *case_high_p != case_high)
2304 *case_high_p = convert (type, case_high);
2305
2306 return true;
2307}
2308\f
2309/* Return an integer type with BITS bits of precision,
2310 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2311
2312tree
2313c_common_type_for_size (unsigned int bits, int unsignedp)
2314{
2315 if (bits == TYPE_PRECISION (integer_type_node))
2316 return unsignedp ? unsigned_type_node : integer_type_node;
2317
2318 if (bits == TYPE_PRECISION (signed_char_type_node))
2319 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2320
2321 if (bits == TYPE_PRECISION (short_integer_type_node))
2322 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2323
2324 if (bits == TYPE_PRECISION (long_integer_type_node))
2325 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2326
2327 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2328 return (unsignedp ? long_long_unsigned_type_node
2329 : long_long_integer_type_node);
2330
2331 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2332 return (unsignedp ? widest_unsigned_literal_type_node
2333 : widest_integer_literal_type_node);
2334
2335 if (bits <= TYPE_PRECISION (intQI_type_node))
2336 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2337
2338 if (bits <= TYPE_PRECISION (intHI_type_node))
2339 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2340
2341 if (bits <= TYPE_PRECISION (intSI_type_node))
2342 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2343
2344 if (bits <= TYPE_PRECISION (intDI_type_node))
2345 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2346
2347 return 0;
2348}
2349
2350/* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2351 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2352 and saturating if SATP is nonzero, otherwise not saturating. */
2353
2354tree
2355c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2356 int unsignedp, int satp)
2357{
2358 enum machine_mode mode;
2359 if (ibit == 0)
2360 mode = unsignedp ? UQQmode : QQmode;
2361 else
2362 mode = unsignedp ? UHAmode : HAmode;
2363
2364 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2365 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2366 break;
2367
2368 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2369 {
2370 sorry ("GCC cannot support operators with integer types and "
2371 "fixed-point types that have too many integral and "
2372 "fractional bits together");
2373 return 0;
2374 }
2375
2376 return c_common_type_for_mode (mode, satp);
2377}
2378
2379/* Used for communication between c_common_type_for_mode and
2380 c_register_builtin_type. */
2381static GTY(()) tree registered_builtin_types;
2382
2383/* Return a data type that has machine mode MODE.
2384 If the mode is an integer,
2385 then UNSIGNEDP selects between signed and unsigned types.
2386 If the mode is a fixed-point mode,
2387 then UNSIGNEDP selects between saturating and nonsaturating types. */
2388
2389tree
2390c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2391{
2392 tree t;
2393
2394 if (mode == TYPE_MODE (integer_type_node))
2395 return unsignedp ? unsigned_type_node : integer_type_node;
2396
2397 if (mode == TYPE_MODE (signed_char_type_node))
2398 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2399
2400 if (mode == TYPE_MODE (short_integer_type_node))
2401 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2402
2403 if (mode == TYPE_MODE (long_integer_type_node))
2404 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2405
2406 if (mode == TYPE_MODE (long_long_integer_type_node))
2407 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2408
2409 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2410 return unsignedp ? widest_unsigned_literal_type_node
2411 : widest_integer_literal_type_node;
2412
2413 if (mode == QImode)
2414 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2415
2416 if (mode == HImode)
2417 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2418
2419 if (mode == SImode)
2420 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2421
2422 if (mode == DImode)
2423 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2424
2425#if HOST_BITS_PER_WIDE_INT >= 64
2426 if (mode == TYPE_MODE (intTI_type_node))
2427 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2428#endif
2429
2430 if (mode == TYPE_MODE (float_type_node))
2431 return float_type_node;
2432
2433 if (mode == TYPE_MODE (double_type_node))
2434 return double_type_node;
2435
2436 if (mode == TYPE_MODE (long_double_type_node))
2437 return long_double_type_node;
2438
2439 if (mode == TYPE_MODE (void_type_node))
2440 return void_type_node;
2441
2442 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2443 return (unsignedp
2444 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2445 : make_signed_type (GET_MODE_PRECISION (mode)));
2446
2447 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2448 return (unsignedp
2449 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2450 : make_signed_type (GET_MODE_PRECISION (mode)));
2451
2452 if (COMPLEX_MODE_P (mode))
2453 {
2454 enum machine_mode inner_mode;
2455 tree inner_type;
2456
2457 if (mode == TYPE_MODE (complex_float_type_node))
2458 return complex_float_type_node;
2459 if (mode == TYPE_MODE (complex_double_type_node))
2460 return complex_double_type_node;
2461 if (mode == TYPE_MODE (complex_long_double_type_node))
2462 return complex_long_double_type_node;
2463
2464 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2465 return complex_integer_type_node;
2466
2467 inner_mode = GET_MODE_INNER (mode);
2468 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2469 if (inner_type != NULL_TREE)
2470 return build_complex_type (inner_type);
2471 }
2472 else if (VECTOR_MODE_P (mode))
2473 {
2474 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2475 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2476 if (inner_type != NULL_TREE)
2477 return build_vector_type_for_mode (inner_type, mode);
2478 }
2479
2480 if (mode == TYPE_MODE (dfloat32_type_node))
2481 return dfloat32_type_node;
2482 if (mode == TYPE_MODE (dfloat64_type_node))
2483 return dfloat64_type_node;
2484 if (mode == TYPE_MODE (dfloat128_type_node))
2485 return dfloat128_type_node;
2486
2487 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2488 {
2489 if (mode == TYPE_MODE (short_fract_type_node))
2490 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2491 if (mode == TYPE_MODE (fract_type_node))
2492 return unsignedp ? sat_fract_type_node : fract_type_node;
2493 if (mode == TYPE_MODE (long_fract_type_node))
2494 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2495 if (mode == TYPE_MODE (long_long_fract_type_node))
2496 return unsignedp ? sat_long_long_fract_type_node
2497 : long_long_fract_type_node;
2498
2499 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2500 return unsignedp ? sat_unsigned_short_fract_type_node
2501 : unsigned_short_fract_type_node;
2502 if (mode == TYPE_MODE (unsigned_fract_type_node))
2503 return unsignedp ? sat_unsigned_fract_type_node
2504 : unsigned_fract_type_node;
2505 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2506 return unsignedp ? sat_unsigned_long_fract_type_node
2507 : unsigned_long_fract_type_node;
2508 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2509 return unsignedp ? sat_unsigned_long_long_fract_type_node
2510 : unsigned_long_long_fract_type_node;
2511
2512 if (mode == TYPE_MODE (short_accum_type_node))
2513 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2514 if (mode == TYPE_MODE (accum_type_node))
2515 return unsignedp ? sat_accum_type_node : accum_type_node;
2516 if (mode == TYPE_MODE (long_accum_type_node))
2517 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2518 if (mode == TYPE_MODE (long_long_accum_type_node))
2519 return unsignedp ? sat_long_long_accum_type_node
2520 : long_long_accum_type_node;
2521
2522 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2523 return unsignedp ? sat_unsigned_short_accum_type_node
2524 : unsigned_short_accum_type_node;
2525 if (mode == TYPE_MODE (unsigned_accum_type_node))
2526 return unsignedp ? sat_unsigned_accum_type_node
2527 : unsigned_accum_type_node;
2528 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2529 return unsignedp ? sat_unsigned_long_accum_type_node
2530 : unsigned_long_accum_type_node;
2531 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2532 return unsignedp ? sat_unsigned_long_long_accum_type_node
2533 : unsigned_long_long_accum_type_node;
2534
2535 if (mode == QQmode)
2536 return unsignedp ? sat_qq_type_node : qq_type_node;
2537 if (mode == HQmode)
2538 return unsignedp ? sat_hq_type_node : hq_type_node;
2539 if (mode == SQmode)
2540 return unsignedp ? sat_sq_type_node : sq_type_node;
2541 if (mode == DQmode)
2542 return unsignedp ? sat_dq_type_node : dq_type_node;
2543 if (mode == TQmode)
2544 return unsignedp ? sat_tq_type_node : tq_type_node;
2545
2546 if (mode == UQQmode)
2547 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2548 if (mode == UHQmode)
2549 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2550 if (mode == USQmode)
2551 return unsignedp ? sat_usq_type_node : usq_type_node;
2552 if (mode == UDQmode)
2553 return unsignedp ? sat_udq_type_node : udq_type_node;
2554 if (mode == UTQmode)
2555 return unsignedp ? sat_utq_type_node : utq_type_node;
2556
2557 if (mode == HAmode)
2558 return unsignedp ? sat_ha_type_node : ha_type_node;
2559 if (mode == SAmode)
2560 return unsignedp ? sat_sa_type_node : sa_type_node;
2561 if (mode == DAmode)
2562 return unsignedp ? sat_da_type_node : da_type_node;
2563 if (mode == TAmode)
2564 return unsignedp ? sat_ta_type_node : ta_type_node;
2565
2566 if (mode == UHAmode)
2567 return unsignedp ? sat_uha_type_node : uha_type_node;
2568 if (mode == USAmode)
2569 return unsignedp ? sat_usa_type_node : usa_type_node;
2570 if (mode == UDAmode)
2571 return unsignedp ? sat_uda_type_node : uda_type_node;
2572 if (mode == UTAmode)
2573 return unsignedp ? sat_uta_type_node : uta_type_node;
2574 }
2575
2576 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2577 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2578 return TREE_VALUE (t);
2579
2580 return 0;
2581}
2582
2583tree
2584c_common_unsigned_type (tree type)
2585{
2586 return c_common_signed_or_unsigned_type (1, type);
2587}
2588
2589/* Return a signed type the same as TYPE in other respects. */
2590
2591tree
2592c_common_signed_type (tree type)
2593{
2594 return c_common_signed_or_unsigned_type (0, type);
2595}
2596
2597/* Return a type the same as TYPE except unsigned or
2598 signed according to UNSIGNEDP. */
2599
2600tree
2601c_common_signed_or_unsigned_type (int unsignedp, tree type)
2602{
2603 tree type1;
2604
2605 /* This block of code emulates the behavior of the old
2606 c_common_unsigned_type. In particular, it returns
2607 long_unsigned_type_node if passed a long, even when a int would
2608 have the same size. This is necessary for warnings to work
2609 correctly in archs where sizeof(int) == sizeof(long) */
2610
2611 type1 = TYPE_MAIN_VARIANT (type);
2612 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2613 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2614 if (type1 == integer_type_node || type1 == unsigned_type_node)
2615 return unsignedp ? unsigned_type_node : integer_type_node;
2616 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2617 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2618 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2619 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2620 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2621 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2622 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2623 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2624#if HOST_BITS_PER_WIDE_INT >= 64
2625 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2626 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2627#endif
2628 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2629 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2630 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2631 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2632 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2633 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2634 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2635 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2636
2637#define C_COMMON_FIXED_TYPES(NAME) \
2638 if (type1 == short_ ## NAME ## _type_node \
2639 || type1 == unsigned_short_ ## NAME ## _type_node) \
2640 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2641 : short_ ## NAME ## _type_node; \
2642 if (type1 == NAME ## _type_node \
2643 || type1 == unsigned_ ## NAME ## _type_node) \
2644 return unsignedp ? unsigned_ ## NAME ## _type_node \
2645 : NAME ## _type_node; \
2646 if (type1 == long_ ## NAME ## _type_node \
2647 || type1 == unsigned_long_ ## NAME ## _type_node) \
2648 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2649 : long_ ## NAME ## _type_node; \
2650 if (type1 == long_long_ ## NAME ## _type_node \
2651 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2652 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2653 : long_long_ ## NAME ## _type_node;
2654
2655#define C_COMMON_FIXED_MODE_TYPES(NAME) \
2656 if (type1 == NAME ## _type_node \
2657 || type1 == u ## NAME ## _type_node) \
2658 return unsignedp ? u ## NAME ## _type_node \
2659 : NAME ## _type_node;
2660
2661#define C_COMMON_FIXED_TYPES_SAT(NAME) \
2662 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2663 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2664 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2665 : sat_ ## short_ ## NAME ## _type_node; \
2666 if (type1 == sat_ ## NAME ## _type_node \
2667 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2668 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2669 : sat_ ## NAME ## _type_node; \
2670 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2671 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2672 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2673 : sat_ ## long_ ## NAME ## _type_node; \
2674 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2675 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2676 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2677 : sat_ ## long_long_ ## NAME ## _type_node;
2678
2679#define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2680 if (type1 == sat_ ## NAME ## _type_node \
2681 || type1 == sat_ ## u ## NAME ## _type_node) \
2682 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2683 : sat_ ## NAME ## _type_node;
2684
2685 C_COMMON_FIXED_TYPES (fract);
2686 C_COMMON_FIXED_TYPES_SAT (fract);
2687 C_COMMON_FIXED_TYPES (accum);
2688 C_COMMON_FIXED_TYPES_SAT (accum);
2689
2690 C_COMMON_FIXED_MODE_TYPES (qq);
2691 C_COMMON_FIXED_MODE_TYPES (hq);
2692 C_COMMON_FIXED_MODE_TYPES (sq);
2693 C_COMMON_FIXED_MODE_TYPES (dq);
2694 C_COMMON_FIXED_MODE_TYPES (tq);
2695 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
2696 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
2697 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
2698 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
2699 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
2700 C_COMMON_FIXED_MODE_TYPES (ha);
2701 C_COMMON_FIXED_MODE_TYPES (sa);
2702 C_COMMON_FIXED_MODE_TYPES (da);
2703 C_COMMON_FIXED_MODE_TYPES (ta);
2704 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
2705 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
2706 C_COMMON_FIXED_MODE_TYPES_SAT (da);
2707 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
2708
2709 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2710 the precision; they have precision set to match their range, but
2711 may use a wider mode to match an ABI. If we change modes, we may
2712 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2713 the precision as well, so as to yield correct results for
2714 bit-field types. C++ does not have these separate bit-field
2715 types, and producing a signed or unsigned variant of an
2716 ENUMERAL_TYPE may cause other problems as well. */
2717
2718 if (!INTEGRAL_TYPE_P (type)
2719 || TYPE_UNSIGNED (type) == unsignedp)
2720 return type;
2721
2722#define TYPE_OK(node) \
2723 (TYPE_MODE (type) == TYPE_MODE (node) \
2724 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2725 if (TYPE_OK (signed_char_type_node))
2726 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2727 if (TYPE_OK (integer_type_node))
2728 return unsignedp ? unsigned_type_node : integer_type_node;
2729 if (TYPE_OK (short_integer_type_node))
2730 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2731 if (TYPE_OK (long_integer_type_node))
2732 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2733 if (TYPE_OK (long_long_integer_type_node))
2734 return (unsignedp ? long_long_unsigned_type_node
2735 : long_long_integer_type_node);
2736 if (TYPE_OK (widest_integer_literal_type_node))
2737 return (unsignedp ? widest_unsigned_literal_type_node
2738 : widest_integer_literal_type_node);
2739
2740#if HOST_BITS_PER_WIDE_INT >= 64
2741 if (TYPE_OK (intTI_type_node))
2742 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2743#endif
2744 if (TYPE_OK (intDI_type_node))
2745 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2746 if (TYPE_OK (intSI_type_node))
2747 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2748 if (TYPE_OK (intHI_type_node))
2749 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2750 if (TYPE_OK (intQI_type_node))
2751 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2752#undef TYPE_OK
2753
2754 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2755}
2756
2757/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2758
2759tree
2760c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2761{
2762 /* Extended integer types of the same width as a standard type have
2763 lesser rank, so those of the same width as int promote to int or
2764 unsigned int and are valid for printf formats expecting int or
2765 unsigned int. To avoid such special cases, avoid creating
2766 extended integer types for bit-fields if a standard integer type
2767 is available. */
2768 if (width == TYPE_PRECISION (integer_type_node))
2769 return unsignedp ? unsigned_type_node : integer_type_node;
2770 if (width == TYPE_PRECISION (signed_char_type_node))
2771 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2772 if (width == TYPE_PRECISION (short_integer_type_node))
2773 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2774 if (width == TYPE_PRECISION (long_integer_type_node))
2775 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2776 if (width == TYPE_PRECISION (long_long_integer_type_node))
2777 return (unsignedp ? long_long_unsigned_type_node
2778 : long_long_integer_type_node);
2779 return build_nonstandard_integer_type (width, unsignedp);
2780}
2781
2782/* The C version of the register_builtin_type langhook. */
2783
2784void
2785c_register_builtin_type (tree type, const char* name)
2786{
2787 tree decl;
2788
2789 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2790 DECL_ARTIFICIAL (decl) = 1;
2791 if (!TYPE_NAME (type))
2792 TYPE_NAME (type) = decl;
2793 pushdecl (decl);
2794
2795 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2796}
2797\f
2798/* Print an error message for invalid operands to arith operation
2799 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2800 LOCATION is the location of the message. */
2801
2802void
2803binary_op_error (location_t location, enum tree_code code,
2804 tree type0, tree type1)
2805{
2806 const char *opname;
2807
2808 switch (code)
2809 {
2810 case PLUS_EXPR:
2811 opname = "+"; break;
2812 case MINUS_EXPR:
2813 opname = "-"; break;
2814 case MULT_EXPR:
2815 opname = "*"; break;
2816 case MAX_EXPR:
2817 opname = "max"; break;
2818 case MIN_EXPR:
2819 opname = "min"; break;
2820 case EQ_EXPR:
2821 opname = "=="; break;
2822 case NE_EXPR:
2823 opname = "!="; break;
2824 case LE_EXPR:
2825 opname = "<="; break;
2826 case GE_EXPR:
2827 opname = ">="; break;
2828 case LT_EXPR:
2829 opname = "<"; break;
2830 case GT_EXPR:
2831 opname = ">"; break;
2832 case LSHIFT_EXPR:
2833 opname = "<<"; break;
2834 case RSHIFT_EXPR:
2835 opname = ">>"; break;
2836 case TRUNC_MOD_EXPR:
2837 case FLOOR_MOD_EXPR:
2838 opname = "%"; break;
2839 case TRUNC_DIV_EXPR:
2840 case FLOOR_DIV_EXPR:
2841 opname = "/"; break;
2842 case BIT_AND_EXPR:
2843 opname = "&"; break;
2844 case BIT_IOR_EXPR:
2845 opname = "|"; break;
2846 case TRUTH_ANDIF_EXPR:
2847 opname = "&&"; break;
2848 case TRUTH_ORIF_EXPR:
2849 opname = "||"; break;
2850 case BIT_XOR_EXPR:
2851 opname = "^"; break;
2852 default:
2853 gcc_unreachable ();
2854 }
2855 error_at (location,
2856 "invalid operands to binary %s (have %qT and %qT)", opname,
2857 type0, type1);
2858}
2859\f
2860/* Subroutine of build_binary_op, used for comparison operations.
2861 See if the operands have both been converted from subword integer types
2862 and, if so, perhaps change them both back to their original type.
2863 This function is also responsible for converting the two operands
2864 to the proper common type for comparison.
2865
2866 The arguments of this function are all pointers to local variables
2867 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2868 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2869
2870 If this function returns nonzero, it means that the comparison has
2871 a constant value. What this function returns is an expression for
2872 that value. */
2873
2874tree
2875shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2876 enum tree_code *rescode_ptr)
2877{
2878 tree type;
2879 tree op0 = *op0_ptr;
2880 tree op1 = *op1_ptr;
2881 int unsignedp0, unsignedp1;
2882 int real1, real2;
2883 tree primop0, primop1;
2884 enum tree_code code = *rescode_ptr;
2885
2886 /* Throw away any conversions to wider types
2887 already present in the operands. */
2888
2889 primop0 = get_narrower (op0, &unsignedp0);
2890 primop1 = get_narrower (op1, &unsignedp1);
2891
2892 /* Handle the case that OP0 does not *contain* a conversion
2893 but it *requires* conversion to FINAL_TYPE. */
2894
2895 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2896 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2897 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2898 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2899
2900 /* If one of the operands must be floated, we cannot optimize. */
2901 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2902 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2903
2904 /* If first arg is constant, swap the args (changing operation
2905 so value is preserved), for canonicalization. Don't do this if
2906 the second arg is 0. */
2907
2908 if (TREE_CONSTANT (primop0)
2909 && !integer_zerop (primop1) && !real_zerop (primop1)
2910 && !fixed_zerop (primop1))
2911 {
2912 tree tem = primop0;
2913 int temi = unsignedp0;
2914 primop0 = primop1;
2915 primop1 = tem;
2916 tem = op0;
2917 op0 = op1;
2918 op1 = tem;
2919 *op0_ptr = op0;
2920 *op1_ptr = op1;
2921 unsignedp0 = unsignedp1;
2922 unsignedp1 = temi;
2923 temi = real1;
2924 real1 = real2;
2925 real2 = temi;
2926
2927 switch (code)
2928 {
2929 case LT_EXPR:
2930 code = GT_EXPR;
2931 break;
2932 case GT_EXPR:
2933 code = LT_EXPR;
2934 break;
2935 case LE_EXPR:
2936 code = GE_EXPR;
2937 break;
2938 case GE_EXPR:
2939 code = LE_EXPR;
2940 break;
2941 default:
2942 break;
2943 }
2944 *rescode_ptr = code;
2945 }
2946
2947 /* If comparing an integer against a constant more bits wide,
2948 maybe we can deduce a value of 1 or 0 independent of the data.
2949 Or else truncate the constant now
2950 rather than extend the variable at run time.
2951
2952 This is only interesting if the constant is the wider arg.
2953 Also, it is not safe if the constant is unsigned and the
2954 variable arg is signed, since in this case the variable
2955 would be sign-extended and then regarded as unsigned.
2956 Our technique fails in this case because the lowest/highest
2957 possible unsigned results don't follow naturally from the
2958 lowest/highest possible values of the variable operand.
2959 For just EQ_EXPR and NE_EXPR there is another technique that
2960 could be used: see if the constant can be faithfully represented
2961 in the other operand's type, by truncating it and reextending it
2962 and see if that preserves the constant's value. */
2963
2964 if (!real1 && !real2
2965 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
2966 && TREE_CODE (primop1) == INTEGER_CST
2967 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2968 {
2969 int min_gt, max_gt, min_lt, max_lt;
2970 tree maxval, minval;
2971 /* 1 if comparison is nominally unsigned. */
2972 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2973 tree val;
2974
2975 type = c_common_signed_or_unsigned_type (unsignedp0,
2976 TREE_TYPE (primop0));
2977
2978 maxval = TYPE_MAX_VALUE (type);
2979 minval = TYPE_MIN_VALUE (type);
2980
2981 if (unsignedp && !unsignedp0)
2982 *restype_ptr = c_common_signed_type (*restype_ptr);
2983
2984 if (TREE_TYPE (primop1) != *restype_ptr)
2985 {
2986 /* Convert primop1 to target type, but do not introduce
2987 additional overflow. We know primop1 is an int_cst. */
2988 primop1 = force_fit_type_double (*restype_ptr,
2989 TREE_INT_CST_LOW (primop1),
2990 TREE_INT_CST_HIGH (primop1), 0,
2991 TREE_OVERFLOW (primop1));
2992 }
2993 if (type != *restype_ptr)
2994 {
2995 minval = convert (*restype_ptr, minval);
2996 maxval = convert (*restype_ptr, maxval);
2997 }
2998
2999 if (unsignedp && unsignedp0)
3000 {
3001 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3002 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3003 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3004 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3005 }
3006 else
3007 {
3008 min_gt = INT_CST_LT (primop1, minval);
3009 max_gt = INT_CST_LT (primop1, maxval);
3010 min_lt = INT_CST_LT (minval, primop1);
3011 max_lt = INT_CST_LT (maxval, primop1);
3012 }
3013
3014 val = 0;
3015 /* This used to be a switch, but Genix compiler can't handle that. */
3016 if (code == NE_EXPR)
3017 {
3018 if (max_lt || min_gt)
3019 val = truthvalue_true_node;
3020 }
3021 else if (code == EQ_EXPR)
3022 {
3023 if (max_lt || min_gt)
3024 val = truthvalue_false_node;
3025 }
3026 else if (code == LT_EXPR)
3027 {
3028 if (max_lt)
3029 val = truthvalue_true_node;
3030 if (!min_lt)
3031 val = truthvalue_false_node;
3032 }
3033 else if (code == GT_EXPR)
3034 {
3035 if (min_gt)
3036 val = truthvalue_true_node;
3037 if (!max_gt)
3038 val = truthvalue_false_node;
3039 }
3040 else if (code == LE_EXPR)
3041 {
3042 if (!max_gt)
3043 val = truthvalue_true_node;
3044 if (min_gt)
3045 val = truthvalue_false_node;
3046 }
3047 else if (code == GE_EXPR)
3048 {
3049 if (!min_lt)
3050 val = truthvalue_true_node;
3051 if (max_lt)
3052 val = truthvalue_false_node;
3053 }
3054
3055 /* If primop0 was sign-extended and unsigned comparison specd,
3056 we did a signed comparison above using the signed type bounds.
3057 But the comparison we output must be unsigned.
3058
3059 Also, for inequalities, VAL is no good; but if the signed
3060 comparison had *any* fixed result, it follows that the
3061 unsigned comparison just tests the sign in reverse
3062 (positive values are LE, negative ones GE).
3063 So we can generate an unsigned comparison
3064 against an extreme value of the signed type. */
3065
3066 if (unsignedp && !unsignedp0)
3067 {
3068 if (val != 0)
3069 switch (code)
3070 {
3071 case LT_EXPR:
3072 case GE_EXPR:
3073 primop1 = TYPE_MIN_VALUE (type);
3074 val = 0;
3075 break;
3076
3077 case LE_EXPR:
3078 case GT_EXPR:
3079 primop1 = TYPE_MAX_VALUE (type);
3080 val = 0;
3081 break;
3082
3083 default:
3084 break;
3085 }
3086 type = c_common_unsigned_type (type);
3087 }
3088
3089 if (TREE_CODE (primop0) != INTEGER_CST)
3090 {
3091 if (val == truthvalue_false_node)
3092 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3093 if (val == truthvalue_true_node)
3094 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3095 }
3096
3097 if (val != 0)
3098 {
3099 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3100 if (TREE_SIDE_EFFECTS (primop0))
3101 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3102 return val;
3103 }
3104
3105 /* Value is not predetermined, but do the comparison
3106 in the type of the operand that is not constant.
3107 TYPE is already properly set. */
3108 }
3109
3110 /* If either arg is decimal float and the other is float, find the
3111 proper common type to use for comparison. */
3112 else if (real1 && real2
3113 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3114 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3115 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3116
3117 else if (real1 && real2
3118 && (TYPE_PRECISION (TREE_TYPE (primop0))
3119 == TYPE_PRECISION (TREE_TYPE (primop1))))
3120 type = TREE_TYPE (primop0);
3121
3122 /* If args' natural types are both narrower than nominal type
3123 and both extend in the same manner, compare them
3124 in the type of the wider arg.
3125 Otherwise must actually extend both to the nominal
3126 common type lest different ways of extending
3127 alter the result.
3128 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3129
3130 else if (unsignedp0 == unsignedp1 && real1 == real2
3131 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3132 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3133 {
3134 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3135 type = c_common_signed_or_unsigned_type (unsignedp0
3136 || TYPE_UNSIGNED (*restype_ptr),
3137 type);
3138 /* Make sure shorter operand is extended the right way
3139 to match the longer operand. */
3140 primop0
3141 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3142 TREE_TYPE (primop0)),
3143 primop0);
3144 primop1
3145 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3146 TREE_TYPE (primop1)),
3147 primop1);
3148 }
3149 else
3150 {
3151 /* Here we must do the comparison on the nominal type
3152 using the args exactly as we received them. */
3153 type = *restype_ptr;
3154 primop0 = op0;
3155 primop1 = op1;
3156
3157 if (!real1 && !real2 && integer_zerop (primop1)
3158 && TYPE_UNSIGNED (*restype_ptr))
3159 {
3160 tree value = 0;
3161 switch (code)
3162 {
3163 case GE_EXPR:
3164 /* All unsigned values are >= 0, so we warn. However,
3165 if OP0 is a constant that is >= 0, the signedness of
3166 the comparison isn't an issue, so suppress the
3167 warning. */
3168 if (warn_type_limits && !in_system_header
3169 && !(TREE_CODE (primop0) == INTEGER_CST
3170 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3171 primop0))))
3172 warning (OPT_Wtype_limits,
3173 "comparison of unsigned expression >= 0 is always true");
3174 value = truthvalue_true_node;
3175 break;
3176
3177 case LT_EXPR:
3178 if (warn_type_limits && !in_system_header
3179 && !(TREE_CODE (primop0) == INTEGER_CST
3180 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3181 primop0))))
3182 warning (OPT_Wtype_limits,
3183 "comparison of unsigned expression < 0 is always false");
3184 value = truthvalue_false_node;
3185 break;
3186
3187 default:
3188 break;
3189 }
3190
3191 if (value != 0)
3192 {
3193 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3194 if (TREE_SIDE_EFFECTS (primop0))
3195 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3196 primop0, value);
3197 return value;
3198 }
3199 }
3200 }
3201
3202 *op0_ptr = convert (type, primop0);
3203 *op1_ptr = convert (type, primop1);
3204
3205 *restype_ptr = truthvalue_type_node;
3206
3207 return 0;
3208}
3209\f
3210/* Return a tree for the sum or difference (RESULTCODE says which)
3211 of pointer PTROP and integer INTOP. */
3212
3213tree
3214pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3215{
3216 tree size_exp, ret;
3217
3218 /* The result is a pointer of the same type that is being added. */
3219 tree result_type = TREE_TYPE (ptrop);
3220
3221 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3222 {
3223 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3224 "pointer of type %<void *%> used in arithmetic");
3225 size_exp = integer_one_node;
3226 }
3227 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3228 {
3229 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3230 "pointer to a function used in arithmetic");
3231 size_exp = integer_one_node;
3232 }
3233 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3234 {
3235 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3236 "pointer to member function used in arithmetic");
3237 size_exp = integer_one_node;
3238 }
3239 else
3240 size_exp = size_in_bytes (TREE_TYPE (result_type));
3241
3242 /* We are manipulating pointer values, so we don't need to warn
3243 about relying on undefined signed overflow. We disable the
3244 warning here because we use integer types so fold won't know that
3245 they are really pointers. */
3246 fold_defer_overflow_warnings ();
3247
3248 /* If what we are about to multiply by the size of the elements
3249 contains a constant term, apply distributive law
3250 and multiply that constant term separately.
3251 This helps produce common subexpressions. */
3252 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3253 && !TREE_CONSTANT (intop)
3254 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3255 && TREE_CONSTANT (size_exp)
3256 /* If the constant comes from pointer subtraction,
3257 skip this optimization--it would cause an error. */
3258 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3259 /* If the constant is unsigned, and smaller than the pointer size,
3260 then we must skip this optimization. This is because it could cause
3261 an overflow error if the constant is negative but INTOP is not. */
3262 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3263 || (TYPE_PRECISION (TREE_TYPE (intop))
3264 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3265 {
3266 enum tree_code subcode = resultcode;
3267 tree int_type = TREE_TYPE (intop);
3268 if (TREE_CODE (intop) == MINUS_EXPR)
3269 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3270 /* Convert both subexpression types to the type of intop,
3271 because weird cases involving pointer arithmetic
3272 can result in a sum or difference with different type args. */
3273 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3274 subcode, ptrop,
3275 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3276 intop = convert (int_type, TREE_OPERAND (intop, 0));
3277 }
3278
3279 /* Convert the integer argument to a type the same size as sizetype
3280 so the multiply won't overflow spuriously. */
3281 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3282 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3283 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3284 TYPE_UNSIGNED (sizetype)), intop);
3285
3286 /* Replace the integer argument with a suitable product by the object size.
3287 Do this multiplication as signed, then convert to the appropriate
3288 type for the pointer operation. */
3289 intop = convert (sizetype,
3290 build_binary_op (EXPR_LOCATION (intop),
3291 MULT_EXPR, intop,
3292 convert (TREE_TYPE (intop), size_exp), 1));
3293
3294 /* Create the sum or difference. */
3295 if (resultcode == MINUS_EXPR)
3296 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3297
3298 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3299
3300 fold_undefer_and_ignore_overflow_warnings ();
3301
3302 return ret;
3303}
3304\f
3305/* Return whether EXPR is a declaration whose address can never be
3306 NULL. */
3307
3308bool
3309decl_with_nonnull_addr_p (const_tree expr)
3310{
3311 return (DECL_P (expr)
3312 && (TREE_CODE (expr) == PARM_DECL
3313 || TREE_CODE (expr) == LABEL_DECL
3314 || !DECL_WEAK (expr)));
3315}
3316
3317/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3318 or for an `if' or `while' statement or ?..: exp. It should already
3319 have been validated to be of suitable type; otherwise, a bad
3320 diagnostic may result.
3321
3322 The EXPR is located at LOCATION.
3323
3324 This preparation consists of taking the ordinary
3325 representation of an expression expr and producing a valid tree
3326 boolean expression describing whether expr is nonzero. We could
3327 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3328 but we optimize comparisons, &&, ||, and !.
3329
3330 The resulting type should always be `truthvalue_type_node'. */
3331
3332tree
3333c_common_truthvalue_conversion (location_t location, tree expr)
3334{
3335 switch (TREE_CODE (expr))
3336 {
3337 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3338 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3339 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3340 case ORDERED_EXPR: case UNORDERED_EXPR:
3341 if (TREE_TYPE (expr) == truthvalue_type_node)
3342 return expr;
3343 return build2 (TREE_CODE (expr), truthvalue_type_node,
3344 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3345
3346 case TRUTH_ANDIF_EXPR:
3347 case TRUTH_ORIF_EXPR:
3348 case TRUTH_AND_EXPR:
3349 case TRUTH_OR_EXPR:
3350 case TRUTH_XOR_EXPR:
3351 if (TREE_TYPE (expr) == truthvalue_type_node)
3352 return expr;
3353 return build2 (TREE_CODE (expr), truthvalue_type_node,
3354 c_common_truthvalue_conversion (location,
3355 TREE_OPERAND (expr, 0)),
3356 c_common_truthvalue_conversion (location,
3357 TREE_OPERAND (expr, 1)));
3358
3359 case TRUTH_NOT_EXPR:
3360 if (TREE_TYPE (expr) == truthvalue_type_node)
3361 return expr;
3362 return build1 (TREE_CODE (expr), truthvalue_type_node,
3363 c_common_truthvalue_conversion (location,
3364 TREE_OPERAND (expr, 0)));
3365
3366 case ERROR_MARK:
3367 return expr;
3368
3369 case INTEGER_CST:
3370 return integer_zerop (expr) ? truthvalue_false_node
3371 : truthvalue_true_node;
3372
3373 case REAL_CST:
3374 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3375 ? truthvalue_true_node
3376 : truthvalue_false_node;
3377
3378 case FIXED_CST:
3379 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3380 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3381 ? truthvalue_true_node
3382 : truthvalue_false_node;
3383
3384 case FUNCTION_DECL:
3385 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3386 /* Fall through. */
3387
3388 case ADDR_EXPR:
3389 {
3390 tree inner = TREE_OPERAND (expr, 0);
3391 if (decl_with_nonnull_addr_p (inner))
3392 {
3393 /* Common Ada/Pascal programmer's mistake. */
3394 warning_at (location,
3395 OPT_Waddress,
3396 "the address of %qD will always evaluate as %<true%>",
3397 inner);
3398 return truthvalue_true_node;
3399 }
4b1e227d 3400 break;
c251ad9e
SS
3401 }
3402
3403 case COMPLEX_EXPR:
3404 return build_binary_op (EXPR_LOCATION (expr),
3405 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3406 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3407 c_common_truthvalue_conversion (location,
3408 TREE_OPERAND (expr, 0)),
3409 c_common_truthvalue_conversion (location,
3410 TREE_OPERAND (expr, 1)),
3411 0);
3412
3413 case NEGATE_EXPR:
3414 case ABS_EXPR:
3415 case FLOAT_EXPR:
3416 /* These don't change whether an object is nonzero or zero. */
3417 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3418
3419 case LROTATE_EXPR:
3420 case RROTATE_EXPR:
3421 /* These don't change whether an object is zero or nonzero, but
3422 we can't ignore them if their second arg has side-effects. */
3423 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3424 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3425 TREE_OPERAND (expr, 1),
3426 c_common_truthvalue_conversion
3427 (location, TREE_OPERAND (expr, 0)));
3428 else
3429 return c_common_truthvalue_conversion (location,
3430 TREE_OPERAND (expr, 0));
3431
3432 case COND_EXPR:
3433 /* Distribute the conversion into the arms of a COND_EXPR. */
3434 return fold_build3 (COND_EXPR, truthvalue_type_node,
3435 TREE_OPERAND (expr, 0),
3436 c_common_truthvalue_conversion (location,
3437 TREE_OPERAND (expr, 1)),
3438 c_common_truthvalue_conversion (location,
3439 TREE_OPERAND (expr, 2)));
3440
3441 CASE_CONVERT:
3442 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3443 since that affects how `default_conversion' will behave. */
3444 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3445 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3446 break;
3447 /* If this is widening the argument, we can ignore it. */
3448 if (TYPE_PRECISION (TREE_TYPE (expr))
3449 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3450 return c_common_truthvalue_conversion (location,
3451 TREE_OPERAND (expr, 0));
3452 break;
3453
3454 case MODIFY_EXPR:
3455 if (!TREE_NO_WARNING (expr)
3456 && warn_parentheses)
3457 {
3458 warning (OPT_Wparentheses,
3459 "suggest parentheses around assignment used as truth value");
3460 TREE_NO_WARNING (expr) = 1;
3461 }
3462 break;
3463
3464 default:
3465 break;
3466 }
3467
3468 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3469 {
3470 tree t = save_expr (expr);
3471 return (build_binary_op
3472 (EXPR_LOCATION (expr),
3473 (TREE_SIDE_EFFECTS (expr)
3474 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3475 c_common_truthvalue_conversion
3476 (location,
3477 build_unary_op (location, REALPART_EXPR, t, 0)),
3478 c_common_truthvalue_conversion
3479 (location,
3480 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3481 0));
3482 }
3483
3484 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3485 {
3486 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3487 FCONST0 (TYPE_MODE
3488 (TREE_TYPE (expr))));
3489 return build_binary_op (EXPR_LOCATION (expr),
3490 NE_EXPR, expr, fixed_zero_node, 1);
3491 }
3492
3493 return build_binary_op (EXPR_LOCATION (expr),
3494 NE_EXPR, expr, integer_zero_node, 1);
3495}
3496\f
3497static void def_builtin_1 (enum built_in_function fncode,
3498 const char *name,
3499 enum built_in_class fnclass,
3500 tree fntype, tree libtype,
3501 bool both_p, bool fallback_p, bool nonansi_p,
3502 tree fnattrs, bool implicit_p);
3503
3504
3505/* Apply the TYPE_QUALS to the new DECL. */
3506
3507void
3508c_apply_type_quals_to_decl (int type_quals, tree decl)
3509{
3510 tree type = TREE_TYPE (decl);
3511
3512 if (type == error_mark_node)
3513 return;
3514
3515 if (((type_quals & TYPE_QUAL_CONST)
3516 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3517 /* An object declared 'const' is only readonly after it is
3518 initialized. We don't have any way of expressing this currently,
3519 so we need to be conservative and unset TREE_READONLY for types
3520 with constructors. Otherwise aliasing code will ignore stores in
3521 an inline constructor. */
3522 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3523 TREE_READONLY (decl) = 1;
3524 if (type_quals & TYPE_QUAL_VOLATILE)
3525 {
3526 TREE_SIDE_EFFECTS (decl) = 1;
3527 TREE_THIS_VOLATILE (decl) = 1;
3528 }
3529 if (type_quals & TYPE_QUAL_RESTRICT)
3530 {
3531 while (type && TREE_CODE (type) == ARRAY_TYPE)
3532 /* Allow 'restrict' on arrays of pointers.
3533 FIXME currently we just ignore it. */
3534 type = TREE_TYPE (type);
3535 if (!type
3536 || !POINTER_TYPE_P (type)
3537 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3538 error ("invalid use of %<restrict%>");
3539 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3540 /* Indicate we need to make a unique alias set for this pointer.
3541 We can't do it here because it might be pointing to an
3542 incomplete type. */
3543 DECL_POINTER_ALIAS_SET (decl) = -2;
3544 }
3545}
3546
3547/* Hash function for the problem of multiple type definitions in
3548 different files. This must hash all types that will compare
3549 equal via comptypes to the same value. In practice it hashes
3550 on some of the simple stuff and leaves the details to comptypes. */
3551
3552static hashval_t
3553c_type_hash (const void *p)
3554{
3555 int i = 0;
3556 int shift, size;
3557 const_tree const t = (const_tree) p;
3558 tree t2;
3559 switch (TREE_CODE (t))
3560 {
3561 /* For pointers, hash on pointee type plus some swizzling. */
3562 case POINTER_TYPE:
3563 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3564 /* Hash on number of elements and total size. */
3565 case ENUMERAL_TYPE:
3566 shift = 3;
3567 t2 = TYPE_VALUES (t);
3568 break;
3569 case RECORD_TYPE:
3570 shift = 0;
3571 t2 = TYPE_FIELDS (t);
3572 break;
3573 case QUAL_UNION_TYPE:
3574 shift = 1;
3575 t2 = TYPE_FIELDS (t);
3576 break;
3577 case UNION_TYPE:
3578 shift = 2;
3579 t2 = TYPE_FIELDS (t);
3580 break;
3581 default:
3582 gcc_unreachable ();
3583 }
3584 for (; t2; t2 = TREE_CHAIN (t2))
3585 i++;
3586 /* We might have a VLA here. */
3587 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3588 size = 0;
3589 else
3590 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3591 return ((size << 24) | (i << shift));
3592}
3593
3594static GTY((param_is (union tree_node))) htab_t type_hash_table;
3595
3596/* Return the typed-based alias set for T, which may be an expression
3597 or a type. Return -1 if we don't do anything special. */
3598
3599alias_set_type
3600c_common_get_alias_set (tree t)
3601{
3602 tree u;
3603 PTR *slot;
3604
3605 /* Permit type-punning when accessing a union, provided the access
3606 is directly through the union. For example, this code does not
3607 permit taking the address of a union member and then storing
3608 through it. Even the type-punning allowed here is a GCC
3609 extension, albeit a common and useful one; the C standard says
3610 that such accesses have implementation-defined behavior. */
3611 for (u = t;
3612 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3613 u = TREE_OPERAND (u, 0))
3614 if (TREE_CODE (u) == COMPONENT_REF
3615 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3616 return 0;
3617
3618 /* That's all the expressions we handle specially. */
3619 if (!TYPE_P (t))
3620 return -1;
3621
3622 /* The C standard guarantees that any object may be accessed via an
3623 lvalue that has character type. */
3624 if (t == char_type_node
3625 || t == signed_char_type_node
3626 || t == unsigned_char_type_node)
3627 return 0;
3628
3629 /* The C standard specifically allows aliasing between signed and
3630 unsigned variants of the same type. We treat the signed
3631 variant as canonical. */
3632 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3633 {
3634 tree t1 = c_common_signed_type (t);
3635
3636 /* t1 == t can happen for boolean nodes which are always unsigned. */
3637 if (t1 != t)
3638 return get_alias_set (t1);
3639 }
3640 else if (POINTER_TYPE_P (t))
3641 {
3642 tree t1;
3643
3644 /* Unfortunately, there is no canonical form of a pointer type.
3645 In particular, if we have `typedef int I', then `int *', and
3646 `I *' are different types. So, we have to pick a canonical
3647 representative. We do this below.
3648
3649 Technically, this approach is actually more conservative that
3650 it needs to be. In particular, `const int *' and `int *'
3651 should be in different alias sets, according to the C and C++
3652 standard, since their types are not the same, and so,
3653 technically, an `int **' and `const int **' cannot point at
3654 the same thing.
3655
3656 But, the standard is wrong. In particular, this code is
3657 legal C++:
3658
3659 int *ip;
3660 int **ipp = &ip;
3661 const int* const* cipp = ipp;
3662
3663 And, it doesn't make sense for that to be legal unless you
3664 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3665 the pointed-to types. This issue has been reported to the
3666 C++ committee. */
3667 t1 = build_type_no_quals (t);
3668 if (t1 != t)
3669 return get_alias_set (t1);
3670 }
3671
3672 /* Handle the case of multiple type nodes referring to "the same" type,
3673 which occurs with IMA. These share an alias set. FIXME: Currently only
3674 C90 is handled. (In C99 type compatibility is not transitive, which
3675 complicates things mightily. The alias set splay trees can theoretically
3676 represent this, but insertion is tricky when you consider all the
3677 different orders things might arrive in.) */
3678
3679 if (c_language != clk_c || flag_isoc99)
3680 return -1;
3681
3682 /* Save time if there's only one input file. */
3683 if (num_in_fnames == 1)
3684 return -1;
3685
3686 /* Pointers need special handling if they point to any type that
3687 needs special handling (below). */
3688 if (TREE_CODE (t) == POINTER_TYPE)
3689 {
3690 tree t2;
3691 /* Find bottom type under any nested POINTERs. */
3692 for (t2 = TREE_TYPE (t);
3693 TREE_CODE (t2) == POINTER_TYPE;
3694 t2 = TREE_TYPE (t2))
3695 ;
3696 if (TREE_CODE (t2) != RECORD_TYPE
3697 && TREE_CODE (t2) != ENUMERAL_TYPE
3698 && TREE_CODE (t2) != QUAL_UNION_TYPE
3699 && TREE_CODE (t2) != UNION_TYPE)
3700 return -1;
3701 if (TYPE_SIZE (t2) == 0)
3702 return -1;
3703 }
3704 /* These are the only cases that need special handling. */
3705 if (TREE_CODE (t) != RECORD_TYPE
3706 && TREE_CODE (t) != ENUMERAL_TYPE
3707 && TREE_CODE (t) != QUAL_UNION_TYPE
3708 && TREE_CODE (t) != UNION_TYPE
3709 && TREE_CODE (t) != POINTER_TYPE)
3710 return -1;
3711 /* Undefined? */
3712 if (TYPE_SIZE (t) == 0)
3713 return -1;
3714
3715 /* Look up t in hash table. Only one of the compatible types within each
3716 alias set is recorded in the table. */
3717 if (!type_hash_table)
3718 type_hash_table = htab_create_ggc (1021, c_type_hash,
3719 (htab_eq) lang_hooks.types_compatible_p,
3720 NULL);
3721 slot = htab_find_slot (type_hash_table, t, INSERT);
3722 if (*slot != NULL)
3723 {
3724 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3725 return TYPE_ALIAS_SET ((tree)*slot);
3726 }
3727 else
3728 /* Our caller will assign and record (in t) a new alias set; all we need
3729 to do is remember t in the hash table. */
3730 *slot = t;
3731
3732 return -1;
3733}
3734\f
3735/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3736 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3737 flag controls whether we should diagnose possibly ill-formed
3738 constructs or not. */
3739
3740tree
3741c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3742{
3743 const char *op_name;
3744 tree value = NULL;
3745 enum tree_code type_code = TREE_CODE (type);
3746
3747 op_name = is_sizeof ? "sizeof" : "__alignof__";
3748
3749 if (type_code == FUNCTION_TYPE)
3750 {
3751 if (is_sizeof)
3752 {
3753 if (complain && (pedantic || warn_pointer_arith))
3754 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3755 "invalid application of %<sizeof%> to a function type");
3756 else if (!complain)
3757 return error_mark_node;
3758 value = size_one_node;
3759 }
3760 else
3761 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3762 }
3763 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3764 {
3765 if (type_code == VOID_TYPE
3766 && complain && (pedantic || warn_pointer_arith))
3767 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3768 "invalid application of %qs to a void type", op_name);
3769 else if (!complain)
3770 return error_mark_node;
3771 value = size_one_node;
3772 }
3773 else if (!COMPLETE_TYPE_P (type))
3774 {
3775 if (complain)
3776 error ("invalid application of %qs to incomplete type %qT ",
3777 op_name, type);
3778 value = size_zero_node;
3779 }
3780 else
3781 {
3782 if (is_sizeof)
3783 /* Convert in case a char is more than one unit. */
3784 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3785 size_int (TYPE_PRECISION (char_type_node)
3786 / BITS_PER_UNIT));
3787 else
3788 value = size_int (TYPE_ALIGN_UNIT (type));
3789 }
3790
3791 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3792 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3793 never happen. However, this node should really have type
3794 `size_t', which is just a typedef for an ordinary integer type. */
3795 value = fold_convert (size_type_node, value);
3796 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3797
3798 return value;
3799}
3800
3801/* Implement the __alignof keyword: Return the minimum required
3802